create-fullstack-scaffold 0.1.0

package/template/src/cli/modules/config/index.ts

@@ -0,0 +1,132 @@
+import { Command } from 'commander'
+import { getBaseUrl, setBaseUrl, getClient } from '@cli/utils/api'
+import { getLogger } from '@cli/utils/logger'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+const CONFIG_DIR = path.join(os.homedir(), '.biomimic')
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+
+interface Config {
+  baseUrl: string
+  stats?: {
+    totalCalls: number
+    lastCallAt?: string
+    commands?: Record<string, number>
+  }
+  [key: string]: string | number | boolean | undefined | Config['stats']
+}
+
+function loadConfig(): Config {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const content = fs.readFileSync(CONFIG_FILE, 'utf-8')
+      return JSON.parse(content)
+    }
+  } catch {
+    // ignore
+  }
+  return { baseUrl: 'http://localhost:3010' }
+}
+
+function saveConfig(config: Config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2))
+}
+
+export function registerConfigCommands(program: Command) {
+  const config = program.command('config').description('CLI configuration and service management')
+
+  config
+    .command('get')
+    .description('Show current configuration')
+    .option('-k, --key <key>', 'Get specific config key')
+    .action((options: { key?: string }) => {
+      const logger = getLogger()
+      const cfg = loadConfig()
+
+      if (options.key) {
+        const value = cfg[options.key]
+        logger.info(`${options.key}: ${value ?? 'not set'}`)
+      } else {
+        logger.info(JSON.stringify(cfg, null, 2))
+      }
+    })
+
+  config
+    .command('set')
+    .description('Set configuration value')
+    .option('-u, --url <url>', 'Set server URL')
+    .action((options: { url?: string }) => {
+      const logger = getLogger()
+      const cfg = loadConfig()
+
+      if (options.url) {
+        cfg.baseUrl = options.url
+        setBaseUrl(options.url)
+        logger.success(`Server URL set to: ${options.url}`)
+      }
+
+      saveConfig(cfg)
+    })
+
+  config
+    .command('url')
+    .description('Show or set server URL')
+    .argument('[url]', 'New server URL')
+    .action((url?: string) => {
+      const logger = getLogger()
+      if (url) {
+        const cfg = loadConfig()
+        cfg.baseUrl = url
+        setBaseUrl(url)
+        saveConfig(cfg)
+        logger.success(`Server URL set to: ${url}`)
+      } else {
+        logger.info(`Current server URL: ${getBaseUrl()}`)
+      }
+    })
+
+  config
+    .command('status')
+    .description('Check server connection status')
+    .action(async () => {
+      const logger = getLogger()
+      const client = getClient()
+
+      try {
+        type HealthClient = { health: { $get: () => Promise<Response> } }
+        const res = await (client as unknown as HealthClient).health.$get()
+        const data = await res.json()
+        logger.success('Server is reachable')
+        logger.info(JSON.stringify(data, null, 2))
+      } catch (error) {
+        logger.error(`Server not reachable: ${getBaseUrl()}`)
+        logger.error(String(error))
+      }
+    })
+
+  config
+    .command('reset')
+    .description('Reset configuration to defaults')
+    .action(() => {
+      const logger = getLogger()
+      const defaultConfig: Config = { baseUrl: 'http://localhost:3010' }
+      saveConfig(defaultConfig)
+      setBaseUrl(defaultConfig.baseUrl)
+      logger.success('Configuration reset to defaults')
+    })
+
+  config
+    .command('path')
+    .description('Show config file path')
+    .action(() => {
+      const logger = getLogger()
+      logger.info(`Config file: ${CONFIG_FILE}`)
+    })
+}
+
+export { loadConfig, saveConfig, CONFIG_FILE }

package/template/src/cli/modules/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from 'commander'
+import { registerTodoCommands } from './todo'
+import { registerNotificationCommands } from './notification'
+import { registerConfigCommands } from './config'
+
+export function registerModules(program: Command) {
+  registerTodoCommands(program)
+  registerNotificationCommands(program)
+  registerConfigCommands(program)
+}
+
+export { registerTodoCommands, registerNotificationCommands, registerConfigCommands }

package/template/src/cli/modules/notification/index.ts

@@ -0,0 +1,86 @@
+import { Command } from 'commander'
+import { getClient } from '@cli/utils/api'
+import { getLogger } from '@cli/utils/logger'
+
+export function registerNotificationCommands(program: Command) {
+  const notification = program
+    .command('notification')
+    .description('Notification management commands')
+
+  notification
+    .command('list')
+    .description('List all notifications')
+    .option('--unread-only', 'Show only unread notifications')
+    .option('--limit <number>', 'Limit number of results', '20')
+    .action(async (options: { unreadOnly?: boolean; limit?: string }) => {
+      const logger = getLogger()
+      const client = getClient()
+      const unreadOnly = Boolean(options.unreadOnly)
+      const limit = parseInt(options.limit || '20')
+
+      const res = await client.api.notifications.$get({
+        query: { unreadOnly: String(unreadOnly), limit: String(limit) },
+      })
+      const data = await res.json()
+      logger.info(JSON.stringify(data, null, 2))
+    })
+
+  notification
+    .command('create')
+    .description('Create a new notification')
+    .requiredOption('-t, --title <title>', 'Notification title')
+    .requiredOption('-m, --message <message>', 'Notification message')
+    .option('--type <type>', 'Notification type (info|warning|success|error)', 'info')
+    .action(async (options: { title: string; message: string; type: string }) => {
+      const logger = getLogger()
+      const client = getClient()
+
+      const res = await client.api.notifications.$post({
+        json: {
+          type: options.type as 'info' | 'warning' | 'success' | 'error',
+          title: options.title,
+          message: options.message,
+        },
+      })
+      const data = await res.json()
+      logger.success('Notification created')
+      logger.info(JSON.stringify(data, null, 2))
+    })
+
+  notification
+    .command('unread-count')
+    .description('Get unread notification count')
+    .action(async () => {
+      const logger = getLogger()
+      const client = getClient()
+      const res = await client.api.notifications['unread-count'].$get()
+      const data = await res.json()
+      logger.info(JSON.stringify(data, null, 2))
+    })
+
+  notification
+    .command('mark-read')
+    .description('Mark a notification as read')
+    .argument('<id>', 'Notification ID')
+    .action(async (id: string) => {
+      const logger = getLogger()
+      const client = getClient()
+      const res = await client.api.notifications[':id'].read.$patch({ param: { id } })
+      const data = await res.json()
+      logger.success('Notification marked as read')
+      logger.info(JSON.stringify(data, null, 2))
+    })
+
+  notification
+    .command('delete')
+    .description('Delete a notification')
+    .argument('<id>', 'Notification ID')
+    .action(async (id: string) => {
+      const logger = getLogger()
+      const client = getClient()
+      const res = await client.api.notifications[':id'].$delete({ param: { id } })
+      const data = await res.json()
+      logger.success('Notification deleted')
+      logger.info(JSON.stringify(data, null, 2))
+    })
+}

package/template/src/cli/modules/todo/index.ts

@@ -0,0 +1,60 @@
+import { Command } from 'commander'
+import { registerAutoCommand, type RouteConfig } from '@cli/utils/auto-command'
+import { z } from '@hono/zod-openapi'
+
+const TodoStatusSchema = z.enum(['pending', 'in_progress', 'completed'])
+
+const todoRoutes: RouteConfig[] = [
+  {
+    method: 'get',
+    path: '/todos',
+    command: 'list',
+    description: 'List all todos',
+  },
+  {
+    method: 'get',
+    path: '/todos/{id}',
+    command: 'get',
+    description: 'Get a todo by ID',
+    params: z.object({ id: z.string() }),
+  },
+  {
+    method: 'post',
+    path: '/todos',
+    command: 'create',
+    description: 'Create a new todo',
+    body: z.object({
+      title: z.string().min(1),
+      description: z.string().optional(),
+    }),
+  },
+  {
+    method: 'put',
+    path: '/todos/{id}',
+    command: 'update',
+    description: 'Update a todo',
+    params: z.object({ id: z.string() }),
+    body: z.object({
+      title: z.string().optional(),
+      description: z.string().optional(),
+      status: TodoStatusSchema.optional(),
+    }),
+  },
+  {
+    method: 'delete',
+    path: '/todos/{id}',
+    command: 'delete',
+    description: 'Delete a todo',
+    params: z.object({ id: z.string() }),
+  },
+]
+
+export function registerTodoCommands(program: Command) {
+  const todo = program.command('todo').description('Todo management commands')
+
+  for (const route of todoRoutes) {
+    registerAutoCommand(todo, route)
+  }
+}
+
+export { todoRoutes }

package/template/src/cli/rpc/client.ts

@@ -0,0 +1,23 @@
+import { hc } from 'hono/client'
+import type { ClientApiType, AppType } from '@server/index'
+import { WSClientImpl } from '@shared/core/ws-client'
+import { SSEClientImpl } from '@shared/core/sse-client'
+
+export type { AppType }
+
+/**
+ * CLI RPC 请求扩展参数
+ */
+export interface CliFetchExtendOptions {
+  /** 是否显示详细日志 */
+  verbose?: boolean
+  /** 超时时间 */
+  timeout?: number
+}
+
+export function createRPCClient(baseUrl: string) {
+  return hc<ClientApiType>(baseUrl, {
+    webSocket: url => new WSClientImpl(url) as unknown as WebSocket,
+    sse: url => new SSEClientImpl(url),
+  })
+}

package/template/src/cli/rpc/index.ts

@@ -0,0 +1 @@
+export { createRPCClient, type AppType } from './client'

package/template/src/cli/utils/api.ts

@@ -0,0 +1,17 @@
+import { createRPCClient } from '../rpc/client'
+
+const DEFAULT_BASE_URL = 'http://localhost:3010'
+
+let globalBaseUrl = process.env.BIOMIMIC_API_URL || DEFAULT_BASE_URL
+
+export function setBaseUrl(url: string) {
+  globalBaseUrl = url
+}
+
+export function getBaseUrl(): string {
+  return globalBaseUrl
+}
+
+export function getClient() {
+  return createRPCClient(globalBaseUrl)
+}

package/template/src/cli/utils/auto-command.ts

@@ -0,0 +1,229 @@
+import { Command } from 'commander'
+import type { ZodType, ZodObject, ZodOptional } from 'zod'
+import { getClient } from './api'
+import { getLogger } from './logger'
+
+type RouteConfig = {
+  method: 'get' | 'post' | 'put' | 'delete' | 'patch'
+  path: string
+  command: string
+  description: string
+  params?: ZodObject<Record<string, ZodType>>
+  body?: ZodType
+  query?: ZodObject<Record<string, ZodType>>
+}
+
+type CliCommandConfig = {
+  name: string
+  description: string
+  action: (options: Record<string, unknown>, args: string[]) => Promise<void>
+  options?: Array<{
+    flags: string
+    description: string
+    required?: boolean
+    defaultValue?: string
+  }>
+  arguments?: Array<{
+    name: string
+    description: string
+    required?: boolean
+  }>
+}
+
+function extractZodInfo(schema: ZodType): {
+  type: 'string' | 'number' | 'boolean' | 'enum' | 'object'
+  required: boolean
+  enumValues?: string[]
+  defaultValue?: unknown
+} {
+  const def = (schema as unknown as { _def: { typeName: string } })._def
+
+  if (def.typeName === 'ZodOptional') {
+    const inner = (schema as ZodOptional<ZodType>)._def.innerType
+    const info = extractZodInfo(inner)
+    return { ...info, required: false }
+  }
+
+  if (def.typeName === 'ZodDefault') {
+    const innerDef = (
+      schema as unknown as { _def: { innerType: ZodType; defaultValue: () => unknown } }
+    )._def
+    const defaultValue = innerDef.defaultValue()
+    const info = extractZodInfo(innerDef.innerType)
+    return { ...info, required: false, defaultValue }
+  }
+
+  if (def.typeName === 'ZodEnum') {
+    const enumValues = [...(schema as unknown as { _def: { values: string[] } })._def.values]
+    return { type: 'enum', required: true, enumValues }
+  }
+
+  if (def.typeName === 'ZodString') return { type: 'string', required: true }
+  if (def.typeName === 'ZodNumber') return { type: 'number', required: true }
+  if (def.typeName === 'ZodBoolean') return { type: 'boolean', required: true }
+  if (def.typeName === 'ZodObject') return { type: 'object', required: true }
+
+  return { type: 'string', required: true }
+}
+
+function schemaToOptions(schema: ZodObject<Record<string, ZodType>>): CliCommandConfig['options'] {
+  const options: CliCommandConfig['options'] = []
+  const shape = schema.shape
+
+  for (const [key, zodType] of Object.entries(shape)) {
+    const info = extractZodInfo(zodType as ZodType)
+    const longFlag = key.replace(/([A-Z])/g, '-$1').toLowerCase()
+
+    let flags = `--${longFlag} <value>`
+    if (info.type === 'boolean') {
+      flags = `--${longFlag}`
+    }
+
+    let description: string = String(info.type)
+    if (info.enumValues) {
+      description = `${info.type} (${info.enumValues.join('|')})`
+    }
+
+    options.push({
+      flags,
+      description,
+      required: info.required,
+      defaultValue: info.defaultValue as string | undefined,
+    })
+  }
+
+  return options
+}
+
+function pathToApiCall(client: ReturnType<typeof getClient>, _method: string, path: string) {
+  const pathParts = path.split('/').filter(Boolean)
+  let current: unknown = client.api
+
+  for (const part of pathParts) {
+    if (part.startsWith('{') && part.endsWith('}')) {
+      continue
+    }
+    current =
+      (current as Record<string, unknown>)[part] || (current as Record<string, unknown>)[`:${part}`]
+  }
+
+  return current as Record<
+    string,
+    (args: {
+      param?: Record<string, string>
+      query?: Record<string, string>
+      json?: Record<string, unknown>
+    }) => Promise<Response>
+  >
+}
+
+export function createCommandFromRoute(config: RouteConfig): CliCommandConfig {
+  const options: CliCommandConfig['options'] = []
+  const arguments_: CliCommandConfig['arguments'] = []
+
+  if (config.params) {
+    const shape = config.params.shape
+    for (const [key] of Object.entries(shape)) {
+      arguments_.push({
+        name: key,
+        description: `${key} parameter`,
+        required: true,
+      })
+    }
+  }
+
+  if (config.body) {
+    const bodySchema = config.body as ZodObject<Record<string, ZodType>>
+    if (bodySchema.shape) {
+      options.push(...(schemaToOptions(bodySchema) || []))
+    }
+  }
+
+  if (config.query) {
+    options.push(...(schemaToOptions(config.query) || []))
+  }
+
+  return {
+    name: config.command,
+    description: config.description,
+    options,
+    arguments: arguments_,
+    action: async (opts: Record<string, unknown>, args: string[]) => {
+      const logger = getLogger()
+      const client = getClient()
+
+      const param: Record<string, string> = {}
+      if (config.params) {
+        const shape = config.params.shape
+        const keys = Object.keys(shape)
+        keys.forEach((key, i) => {
+          param[key] = args[i] || String(opts[key])
+        })
+      }
+
+      const json: Record<string, unknown> = {}
+      if (config.body && opts) {
+        const bodySchema = config.body as ZodObject<Record<string, ZodType>>
+        if (bodySchema.shape) {
+          const shape = bodySchema.shape
+          for (const key of Object.keys(shape)) {
+            if (opts[key] !== undefined) {
+              json[key] = opts[key]
+            }
+          }
+        }
+      }
+
+      const query: Record<string, string> = {}
+      if (config.query && opts) {
+        const shape = config.query.shape
+        for (const key of Object.keys(shape)) {
+          if (opts[key] !== undefined) {
+            query[key] = String(opts[key])
+          }
+        }
+      }
+
+      const apiCall = pathToApiCall(client, config.method, config.path)
+      const methodCall =
+        apiCall[`$${config.method.charAt(0).toUpperCase() + config.method.slice(1)}`] ||
+        apiCall.$get
+
+      const res = await methodCall.call(apiCall, {
+        param: Object.keys(param).length > 0 ? param : undefined,
+        query: Object.keys(query).length > 0 ? query : undefined,
+        json: Object.keys(json).length > 0 ? json : undefined,
+      })
+
+      const data = await res.json()
+      logger.info(JSON.stringify(data, null, 2))
+    },
+  }
+}
+
+export function registerAutoCommand(program: Command, config: RouteConfig) {
+  const cmd = createCommandFromRoute(config)
+
+  const command = program
+    .command(cmd.name)
+    .description(cmd.description)
+    .action(async (firstArg, opts) => {
+      const args = typeof firstArg === 'string' ? [firstArg] : []
+      const options = (typeof firstArg === 'object' ? firstArg : opts) || {}
+      await cmd.action(options, args)
+    })
+
+  cmd.options?.forEach(opt => {
+    if (opt.required) {
+      command.requiredOption(opt.flags, opt.description, opt.defaultValue)
+    } else {
+      command.option(opt.flags, opt.description, opt.defaultValue)
+    }
+  })
+
+  cmd.arguments?.forEach(arg => {
+    command.argument(arg.required ? `<${arg.name}>` : `[${arg.name}]`, arg.description)
+  })
+}
+
+export { type RouteConfig, type CliCommandConfig }

package/template/src/cli/utils/index.ts

@@ -0,0 +1,8 @@
+export { createLogger, getLogger, Logger, type LogLevel, type LoggerOptions } from './logger'
+export { setBaseUrl, getBaseUrl, getClient } from './api'
+export {
+  registerAutoCommand,
+  createCommandFromRoute,
+  type RouteConfig,
+  type CliCommandConfig,
+} from './auto-command'

package/template/src/cli/utils/logger.ts

@@ -0,0 +1,79 @@
+type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug'
+
+interface LoggerOptions {
+  verbose?: boolean
+  debug?: boolean
+}
+
+class Logger {
+  private level: LogLevel = 'info'
+
+  constructor(options: LoggerOptions = {}) {
+    if (options.debug || process.env.BIOMIMIC_DEBUG === 'true') {
+      this.level = 'debug'
+    } else if (options.verbose || process.env.BIOMIMIC_VERBOSE === 'true') {
+      this.level = 'info'
+    }
+  }
+
+  setLevel(level: LogLevel) {
+    this.level = level
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    const levels: LogLevel[] = ['silent', 'error', 'warn', 'info', 'debug']
+    return levels.indexOf(level) <= levels.indexOf(this.level)
+  }
+
+  info(message: string, ...args: unknown[]) {
+    if (this.shouldLog('info')) {
+      process.stdout.write(`${message}${args.length ? ' ' + args.join(' ') : ''}\n`)
+    }
+  }
+
+  debug(message: string, ...args: unknown[]) {
+    if (this.shouldLog('debug')) {
+      process.stdout.write(`[debug] ${message}${args.length ? ' ' + args.join(' ') : ''}\n`)
+    }
+  }
+
+  warn(message: string) {
+    if (this.shouldLog('warn')) {
+      process.stderr.write(`[warn] ${message}\n`)
+    }
+  }
+
+  error(message: string) {
+    if (this.shouldLog('error')) {
+      process.stderr.write(`[error] ${message}\n`)
+    }
+  }
+
+  success(message: string, ...args: unknown[]) {
+    if (this.shouldLog('info')) {
+      process.stdout.write(`✓ ${message}${args.length ? ' ' + args.join(' ') : ''}\n`)
+    }
+  }
+
+  fail(message: string) {
+    if (this.shouldLog('error')) {
+      process.stderr.write(`✗ ${message}\n`)
+    }
+  }
+}
+
+let logger: Logger | null = null
+
+export function createLogger(options: LoggerOptions = {}): Logger {
+  logger = new Logger(options)
+  return logger
+}
+
+export function getLogger(): Logger {
+  if (!logger) {
+    logger = new Logger()
+  }
+  return logger
+}
+
+export { Logger, type LogLevel, type LoggerOptions }

package/template/src/client/App.tsx

@@ -0,0 +1,24 @@
+import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom'
+import { Layout } from './Layout'
+import { TodoPage } from './pages/TodoPage'
+import { NotificationPage } from './pages/NotificationPage'
+import { WebSocketPage } from './pages/WebSocketPage'
+import { ContentListPage } from './pages/ContentListPage'
+import { ContentDetailPage } from './pages/ContentDetailPage'
+
+export const App: React.FC = () => {
+  return (
+    <BrowserRouter>
+      <Layout>
+        <Routes>
+          <Route path="/" element={<Navigate to="/todos" replace />} />
+          <Route path="/todos" element={<TodoPage />} />
+          <Route path="/notifications" element={<NotificationPage />} />
+          <Route path="/websocket" element={<WebSocketPage />} />
+          <Route path="/content" element={<ContentListPage />} />
+          <Route path="/content/:id" element={<ContentDetailPage />} />
+        </Routes>
+      </Layout>
+    </BrowserRouter>
+  )
+}