@usehyper/cli 0.1.0

package/src/commands/client.ts

@@ -0,0 +1,78 @@
+/**
+ * `hyper client <outDir> [entry]` — emits client.ts + client.d.ts from the
+ * app's `toClientManifest()`. Codegen lives in @hyper/client; the CLI is
+ * responsible for loading the app and writing files.
+ */
+
+import { mkdir, writeFile } from "node:fs/promises"
+import { resolve } from "node:path"
+import { type ParsedArgs, isJson } from "../args.ts"
+import { readConfig } from "../config/index.ts"
+import { resolveEntry } from "../entry.ts"
+import { loadApp } from "../load-app.ts"
+
+export async function runClient(args: ParsedArgs): Promise<number> {
+  const outDir = args.positional[0]
+  if (!outDir) {
+    console.error("usage: hyper client <outDir> [entry]")
+    return 2
+  }
+  const entryArg = args.positional[1] ? [args.positional[1]] : []
+  const entry = await resolveEntry(entryArg)
+  if (!entry) {
+    console.error("error: no entry file found")
+    return 2
+  }
+  const app = await loadApp(entry)
+  if (!app) {
+    console.error(`error: no default/named 'app' export in ${entry}`)
+    return 2
+  }
+
+  // The codegen lives at <baseDir>/client/codegen.ts after `hyper add client`.
+  // We resolve it locally first, with @hyper/client and @hyper/client as fallbacks.
+  const config = await readConfig()
+  const local = resolve(process.cwd(), config.baseDir, "client/codegen.ts")
+  let mod: typeof import("@hyper/client/codegen") | null = null
+  for (const spec of [local, "@hyper/client/codegen", "@hyper/client/codegen"]) {
+    try {
+      mod = (await import(spec)) as typeof import("@hyper/client/codegen")
+      break
+    } catch {
+      // try next
+    }
+  }
+  if (!mod) {
+    console.error(
+      "error: @hyper/client not installed in this project. Run `hyper add client` first.",
+    )
+    return 2
+  }
+  const baseUrl = typeof args.flags.baseUrl === "string" ? args.flags.baseUrl : ""
+  const result = mod.generateClient({
+    manifest: app.toClientManifest(),
+    baseUrl,
+    rootName: typeof args.flags.name === "string" ? args.flags.name : "api",
+    resultTypes: args.flags.resultTypes === true || args.flags["result-types"] === true,
+  })
+
+  const abs = resolve(process.cwd(), outDir)
+  await mkdir(abs, { recursive: true })
+  const runtimePath = resolve(abs, "client.ts")
+  const dtsPath = resolve(abs, "client.d.ts")
+  await writeFile(runtimePath, result.runtime)
+  await writeFile(dtsPath, result.declaration)
+
+  const summary = {
+    runtime: runtimePath,
+    declaration: dtsPath,
+    routeCount: app.routeList.length,
+  }
+  if (isJson(args.flags)) {
+    console.log(JSON.stringify(summary))
+  } else {
+    console.log(`client emitted -> ${abs}`)
+    console.log(`  ${summary.routeCount} route(s)`)
+  }
+  return 0
+}

package/src/commands/dev.ts

@@ -0,0 +1,53 @@
+import { type ChildProcess, spawn } from "node:child_process"
+import type { ParsedArgs } from "../args.ts"
+import { resolveEntry } from "../entry.ts"
+
+/**
+ * `hyper dev` — run the app with Bun hot reload + tsgo --watch alongside.
+ *
+ * We prefer a Bun-native single-process hot reload (`bun --hot` uses
+ * `server.reload` under the hood to keep the open sockets alive). The
+ * type-checker runs as a sibling process so incremental type errors
+ * surface in the terminal without blocking request-handling.
+ *
+ * Flags:
+ *   --test     also run `bun test --watch` in a third sibling process
+ *   --no-types skip `tsgo --watch` (useful when tsgo isn't available)
+ */
+export async function runDev(args: ParsedArgs): Promise<number> {
+  const entry = await resolveEntry(args.positional)
+  if (!entry) {
+    console.error("error: no entry file found (tried src/app.ts, app.ts, src/index.ts)")
+    return 2
+  }
+  const children: ChildProcess[] = []
+  const bun = spawn("bun", ["--hot", entry], { stdio: "inherit" })
+  children.push(bun)
+
+  const runTypes = args.flags.types !== false && args.flags["no-types"] !== true
+  if (runTypes) {
+    const tsgo = spawn("tsgo", ["--noEmit", "--watch", "-p", "tsconfig.json"], {
+      stdio: "inherit",
+    })
+    tsgo.on("error", () => {})
+    children.push(tsgo)
+  }
+
+  if (args.flags.test === true) {
+    const test = spawn("bun", ["test", "--watch"], { stdio: "inherit" })
+    test.on("error", () => {})
+    children.push(test)
+  }
+
+  const cleanup = (): void => {
+    for (const c of children) c.kill("SIGTERM")
+  }
+  process.on("SIGINT", cleanup)
+  process.on("SIGTERM", cleanup)
+  return new Promise<number>((res) => {
+    bun.on("exit", (code) => {
+      for (const c of children) if (c !== bun) c.kill("SIGTERM")
+      res(code ?? 0)
+    })
+  })
+}

package/src/commands/diff.ts

@@ -0,0 +1,80 @@
+/**
+ * `hyper diff <component>` — inspect drift between local files and the
+ * registry version of a component.
+ *
+ * Output per file:
+ *   ok        local sha matches registry (after applying the user's alias)
+ *   drift     local sha differs from registry — print line-diff
+ *   missing   the file isn't installed (run `hyper add` first)
+ */
+
+import type { ParsedArgs } from "../args.ts"
+import { readConfig } from "../config/index.ts"
+import {
+  createRegistryClient,
+  readLocalFile,
+  resolveTarget,
+  rewriteFile,
+} from "../registry/index.ts"
+
+export async function runDiff(args: ParsedArgs): Promise<number> {
+  const name = args.positional[0]
+  if (!name) {
+    console.error("usage: hyper diff <component>")
+    return 2
+  }
+  const config = await readConfig()
+  const client = createRegistryClient({ url: config.registryUrl })
+  const component = await client.getComponent(name).catch(() => null)
+  if (!component) {
+    console.error(`unknown component: ${name}`)
+    return 2
+  }
+
+  const subpathsByComponent = new Map<string, Readonly<Record<string, string>>>([
+    [component.name, component.subpaths],
+  ])
+
+  let drift = 0
+  for (const f of component.files) {
+    const resolved = resolveTarget(f, component.name, config.baseDir)
+    const relPath = resolved.relPath
+    const local = await readLocalFile(process.cwd(), config, component.name, f)
+    if (local === null) {
+      console.log(`missing  ${relPath}`)
+      drift += 1
+      continue
+    }
+    const expected = resolved.rewriteImports
+      ? rewriteFile(f.contents, {
+          alias: config.alias,
+          targetPath: relPath,
+          baseDir: config.baseDir,
+          subpathsByComponent,
+        })
+      : f.contents
+    if (local === expected) {
+      console.log(`ok       ${relPath}`)
+      continue
+    }
+    drift += 1
+    console.log(`drift    ${relPath}`)
+    const changes = lineDiff(expected, local)
+    for (const c of changes.slice(0, 20)) console.log(`   ${c}`)
+    if (changes.length > 20) console.log(`   … (${changes.length - 20} more)`)
+  }
+  return drift > 0 ? 1 : 0
+}
+
+function lineDiff(a: string, b: string): string[] {
+  const aL = a.split("\n")
+  const bL = b.split("\n")
+  const max = Math.max(aL.length, bL.length)
+  const out: string[] = []
+  for (let i = 0; i < max; i++) {
+    if (aL[i] === bL[i]) continue
+    if (aL[i] !== undefined) out.push(`- ${aL[i]}`)
+    if (bL[i] !== undefined) out.push(`+ ${bL[i]}`)
+  }
+  return out
+}

package/src/commands/env.ts

@@ -0,0 +1,92 @@
+import { type ParsedArgs, isJson } from "../args.ts"
+import { resolveEntry } from "../entry.ts"
+import { loadApp, loadComponentModule } from "../load-app.ts"
+
+/**
+ * `hyper env --check` — boots the app just far enough to run env parsing
+ * and reports why/fix. Since boot happens on the first `fetch`, we send
+ * a synthetic request through the app.
+ *
+ * `hyper env --unsafe-print` — resolve env against declared schemas and
+ * print the merged object. Secrets (as declared via `secret(...)` or
+ * the `secrets: [...]` list) are redacted UNLESS this flag is passed,
+ * so the opt-in makes leaking them an explicit, auditable action.
+ */
+export async function runEnvCheck(args: ParsedArgs): Promise<number> {
+  const entry = await resolveEntry(args.positional)
+  if (!entry) {
+    console.error("error: no entry file found")
+    return 2
+  }
+  const app = await loadApp(entry)
+  if (!app) {
+    console.error(`error: no default/named 'app' export in ${entry}`)
+    return 2
+  }
+  const unsafe = args.flags["unsafe-print"] === true || args.flags.unsafePrint === true
+
+  try {
+    const core = await loadComponentModule<typeof import("@hyper/core")>("core")
+    if (!core) {
+      console.error("error: cannot find @hyper/core (run `hyper add core` first?)")
+      return 2
+    }
+    const cfg = app.__config
+    const schemas = collectEnvSchemas(cfg)
+    const secretPaths = Array.isArray(cfg.env?.secrets) ? (cfg.env?.secrets ?? []) : []
+    const source = cfg.env?.source ?? process.env
+    const merged = await core.parseEnv(schemas, source as Record<string, string | undefined>)
+
+    if (unsafe) {
+      const output = { ...merged }
+      if (isJson(args.flags)) console.log(JSON.stringify(output, null, 2))
+      else console.log(JSON.stringify(output, null, 2))
+      return 0
+    }
+
+    const redacted = redact(merged, secretPaths)
+    if (isJson(args.flags)) {
+      console.log(JSON.stringify({ ok: true, env: redacted }))
+    } else {
+      console.log("env ok")
+      console.log(JSON.stringify(redacted, null, 2))
+    }
+    return 0
+  } catch (e) {
+    const body =
+      e instanceof Error
+        ? {
+            error: {
+              name: e.name,
+              message: e.message,
+              issues: (e as unknown as { issues?: unknown }).issues,
+            },
+          }
+        : { error: { message: String(e) } }
+    if (isJson(args.flags)) console.log(JSON.stringify(body))
+    else console.error("env check failed:", JSON.stringify(body, null, 2))
+    return 1
+  }
+}
+
+function collectEnvSchemas(cfg: {
+  env?: { schema?: unknown } | { schema?: unknown }[]
+}): import("@hyper/core").StandardSchemaV1[] {
+  const schemas: import("@hyper/core").StandardSchemaV1[] = []
+  const envCfg = (cfg as { env?: { schema?: unknown } }).env
+  if (envCfg && typeof envCfg === "object" && "schema" in envCfg && envCfg.schema) {
+    schemas.push(envCfg.schema as import("@hyper/core").StandardSchemaV1)
+  }
+  return schemas
+}
+
+function redact(env: Record<string, unknown>, paths: readonly string[]): Record<string, unknown> {
+  if (paths.length === 0) return env
+  const out: Record<string, unknown> = { ...env }
+  for (const p of paths) {
+    if (p in out && out[p] !== undefined) {
+      out[p] = "[redacted]"
+    }
+  }
+  return out
+}

package/src/commands/help.ts

@@ -0,0 +1,42 @@
+export const HELP_TEXT = `hyper — fast, opinionated, AI-native API framework
+
+Usage:
+  hyper <command> [options]
+
+Project commands:
+  init [template]      Scaffold a new app (templates: minimal, api). Writes hyper.config.json + tsconfig paths, then installs core.
+  dev [entry]          Run app with Bun hot reload + tsgo --watch (--test for bun test --watch)
+  build [entry]        Bundle app + emit route graph
+  openapi [out]        Emit OpenAPI 3.1 spec
+  test                 Run .example() contracts + bun:test (--fuzz, --types, --reporter=junit)
+  typecheck            Run tsgo --noEmit against the project
+  env --check          Validate env against declared schema
+  routes [entry]       Print the route graph (--json for machine output)
+  client <out> [entry] Emit a typed RPC client
+  mcp [entry]          Serve dev MCP view (use --audit to print exposed surface)
+  bench [entry]        Run the in-process latency benchmark
+  security --check     Audit secure-by-default posture
+  version              Print version + toolchain info
+
+Registry commands:
+  add <component>...   Copy components into your repo. Resolves deps + rewrites imports.
+                       Flags: --info  --force  --dry-run  --json  --list
+  diff <component>     Show drift between local files and the registry
+  update [component]   Update installed components to the latest registry version
+                       Flags: --force  --dry-run
+  list [query]         List / search the registry catalog (--json)
+  search <query>       Alias of \`hyper list <query>\`
+
+Flags:
+  --json               Machine-readable output for scripting/CI
+  --help, -h           Show this help
+
+Environment:
+  HYPER_REGISTRY_URL   Override the registry base URL (default: https://hyperjs.ai)
+  HYPER_SKIP_LISTEN    Set automatically by introspection commands; user code can opt-out
+`
+
+export function runHelp(): number {
+  console.log(HELP_TEXT)
+  return 0
+}

package/src/commands/init.ts

@@ -0,0 +1,119 @@
+/**
+ * `hyper init [template]` — scaffold a new Hyper app.
+ *
+ *   hyper init                 # minimal template into the current dir
+ *   hyper init api             # api template
+ *   hyper init --dir my-app    # into a subdir
+ *   hyper init --no-install    # skip auto `hyper add core`
+ *   hyper init --agent-rules   # also install the agent-rules component
+ *
+ * The template files have NO `@usehyper/*` deps. After files are written
+ * we run `hyper add` for each `template.components` entry, which copies the
+ * framework source into `<baseDir>/<component>/` and updates the lockfile.
+ */
+
+import { mkdir, stat, writeFile } from "node:fs/promises"
+import { dirname, resolve } from "node:path"
+import { type ParsedArgs, isJson } from "../args.ts"
+import { defaultConfig, patchTsConfig, readLock, writeConfig, writeLock } from "../config/index.ts"
+import { applyComponents, createRegistryClient } from "../registry/index.ts"
+import { TEMPLATES } from "../templates.ts"
+
+export async function runInit(args: ParsedArgs): Promise<number> {
+  const templateName = args.positional[0] ?? "minimal"
+  const targetDir = typeof args.flags.dir === "string" ? args.flags.dir : "."
+  const template = TEMPLATES[templateName]
+  if (!template) {
+    console.error(
+      `unknown template "${templateName}"; available: ${Object.keys(TEMPLATES).join(", ")}`,
+    )
+    return 2
+  }
+
+  const cwd = resolve(process.cwd(), targetDir)
+  await mkdir(cwd, { recursive: true })
+
+  const writtenFiles: string[] = []
+  for (const [rel, contents] of Object.entries(template.files)) {
+    const abs = resolve(cwd, rel)
+    if (await pathExists(abs)) continue // never clobber existing files
+    await mkdir(dirname(abs), { recursive: true })
+    await writeFile(abs, contents)
+    writtenFiles.push(abs)
+  }
+
+  // Write hyper.config.json + patch tsconfig paths.
+  const config = defaultConfig()
+  await writeConfig(config, cwd)
+  await patchTsConfig(config.alias, config.baseDir, cwd)
+
+  // Auto-install template components (core, optionally log, etc.).
+  let componentsInstalled = 0
+  let installPeerDeps: Record<string, string> = {}
+  if (args.flags["no-install"] !== true) {
+    const components = [...template.components]
+    if (args.flags["agent-rules"] === true || args.flags["with-agent-rules"] === true) {
+      components.push("agent-rules")
+    }
+    const client = createRegistryClient({ url: config.registryUrl })
+    const lock = await readLock(cwd)
+    const outcome = await applyComponents(components, {
+      cwd,
+      config,
+      client,
+      lock,
+      force: false,
+      dryRun: false,
+    })
+    await writeLock(outcome.lock, cwd)
+    componentsInstalled = outcome.components.length
+    installPeerDeps = outcome.peerDeps as Record<string, string>
+  }
+
+  if (isJson(args.flags)) {
+    console.log(
+      JSON.stringify({
+        template: template.name,
+        cwd,
+        files: writtenFiles,
+        componentsInstalled,
+      }),
+    )
+    return 0
+  }
+
+  console.log(`initialized "${template.name}" template in ${cwd}`)
+  for (const f of writtenFiles) console.log(`  + ${f}`)
+  if (componentsInstalled > 0) {
+    console.log(`installed ${componentsInstalled} component(s) from ${config.registryUrl}`)
+  }
+
+  console.log("\nnext steps:")
+  console.log(`  cd ${targetDir === "." ? "." : targetDir}`)
+  console.log("  bun install")
+  if (Object.keys(installPeerDeps).length > 0) {
+    console.log(
+      `  bun add ${Object.entries(installPeerDeps)
+        .map(([k, v]) => `${k}@${v}`)
+        .join(" ")}`,
+    )
+  }
+  console.log("  bun run dev")
+  console.log("")
+  console.log("  # for AI agents (Cursor / Claude Code), drop in agent rules:")
+  console.log("  hyper add agent-rules")
+  console.log("")
+  console.log("  # for AI tools to discover this registry, point them at:")
+  console.log(`  ${config.registryUrl}/mcp`)
+
+  return 0
+}
+
+async function pathExists(p: string): Promise<boolean> {
+  try {
+    await stat(p)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/commands/list.ts

@@ -0,0 +1,46 @@
+/**
+ * `hyper list` / `hyper search <q>` — browse the registry from the CLI.
+ *
+ * Reads the index manifest and prints a name/version/description table.
+ * Supports `--json` and a substring filter via positional `query` (used by
+ * `hyper search`).
+ */
+
+import { type ParsedArgs, isJson } from "../args.ts"
+import { readConfig } from "../config/index.ts"
+import { createRegistryClient } from "../registry/index.ts"
+
+export async function runList(args: ParsedArgs): Promise<number> {
+  const config = await readConfig()
+  const client = createRegistryClient({ url: config.registryUrl })
+  const index = await client.getIndex()
+  const q = args.positional[0]?.toLowerCase()
+  const filtered = q
+    ? index.components.filter(
+        (c) =>
+          c.name.toLowerCase().includes(q) ||
+          c.description.toLowerCase().includes(q) ||
+          c.registryDeps.some((d) => d.toLowerCase().includes(q)),
+      )
+    : index.components
+
+  if (isJson(args.flags)) {
+    console.log(JSON.stringify(filtered, null, 2))
+    return 0
+  }
+
+  if (filtered.length === 0) {
+    console.log(q ? `no components matching "${q}"` : "no components in registry")
+    return 0
+  }
+
+  const w = Math.max(8, ...filtered.map((c) => c.name.length))
+  console.log(`registry: ${client.url}`)
+  console.log(`${"name".padEnd(w)}  version  description`)
+  console.log(`${"".padEnd(w, "-")}  -------  -----------`)
+  for (const c of filtered) {
+    console.log(`${c.name.padEnd(w)}  ${c.version.padEnd(7)}  ${c.description}`)
+  }
+  console.log(`\n${filtered.length} component(s)`)
+  return 0
+}

package/src/commands/mcp.ts

@@ -0,0 +1,51 @@
+/**
+ * `hyper mcp` — serve the app over MCP (JSON-RPC).
+ * `hyper mcp --audit` — print the exposed surface without serving.
+ * `hyper mcp --manifest` — write the manifest JSON to stdout.
+ */
+
+import { type ParsedArgs, isJson } from "../args.ts"
+import { resolveEntry } from "../entry.ts"
+import { loadApp, loadComponentModule } from "../load-app.ts"
+
+export async function runMcp(args: ParsedArgs): Promise<number> {
+  const entry = await resolveEntry(args.positional)
+  if (!entry) {
+    console.error("error: no entry file found")
+    return 2
+  }
+  const app = await loadApp(entry)
+  if (!app) {
+    console.error(`error: no default/named 'app' export in ${entry}`)
+    return 2
+  }
+  const mod = await loadComponentModule<typeof import("@hyper/mcp")>("mcp")
+  if (!mod) {
+    console.error("error: @hyper/mcp not installed in this project. Run `hyper add mcp` first.")
+    return 2
+  }
+
+  if (args.flags.manifest === true) {
+    const manifest = app.toMCPManifest()
+    console.log(JSON.stringify(manifest, null, 2))
+    return 0
+  }
+
+  if (args.flags.audit === true) {
+    const report = mod.auditMcp(app)
+    if (isJson(args.flags)) {
+      console.log(JSON.stringify(report, null, 2))
+    } else {
+      console.log(mod.formatAuditHuman(report))
+    }
+    return 0
+  }
+
+  const server = mod.mcpServer(app)
+  const port = Number(args.flags.port ?? process.env.PORT ?? 5174)
+  const bun = Bun.serve({ port, fetch: server.handle })
+  console.log(`MCP server listening on http://localhost:${bun.port}`)
+  process.on("SIGTERM", () => bun.stop(false))
+  process.on("SIGINT", () => bun.stop(false))
+  return await new Promise<number>(() => {})
+}

package/src/commands/openapi.ts

@@ -0,0 +1,50 @@
+/**
+ * `hyper openapi [out]` — emits openapi.json for the current app.
+ *
+ * Dynamically imports @hyper/openapi so consumers without it installed
+ * don't incur the dependency. Falls back to `app.toOpenAPI()` (core).
+ */
+
+import { mkdir, writeFile } from "node:fs/promises"
+import { dirname, resolve } from "node:path"
+import type { ParsedArgs } from "../args.ts"
+import { isJson } from "../args.ts"
+import { resolveEntry } from "../entry.ts"
+import { loadApp, loadComponentModule } from "../load-app.ts"
+
+export async function runOpenapi(args: ParsedArgs): Promise<number> {
+  const entry = await resolveEntry(args.positional.slice(1))
+  if (!entry) {
+    console.error("error: no entry file found")
+    return 2
+  }
+  const app = await loadApp(entry)
+  if (!app) {
+    console.error("error: entry did not export a Hyper app")
+    return 2
+  }
+
+  // Prefer the @hyper/openapi component if installed (richer schema converters);
+  // fall back to core's built-in projector otherwise.
+  let doc: unknown
+  const m = await loadComponentModule<typeof import("@hyper/openapi")>("openapi")
+  if (m) {
+    doc = m.generate(app, {
+      ...(typeof args.flags.title === "string" && { title: args.flags.title }),
+      ...(typeof args.flags.version === "string" && { version: args.flags.version }),
+    })
+  } else {
+    doc = app.toOpenAPI()
+  }
+
+  const out = args.positional[0]
+  if (!out) {
+    console.log(isJson(args.flags) ? JSON.stringify(doc) : JSON.stringify(doc, null, 2))
+    return 0
+  }
+  const abs = resolve(process.cwd(), out)
+  await mkdir(dirname(abs), { recursive: true })
+  await writeFile(abs, `${JSON.stringify(doc, null, 2)}\n`)
+  console.log(`wrote ${abs}`)
+  return 0
+}

package/src/commands/routes.ts

@@ -0,0 +1,45 @@
+import type { HyperApp, Route } from "@hyper/core"
+import { type ParsedArgs, isJson } from "../args.ts"
+import { resolveEntry } from "../entry.ts"
+import { loadApp } from "../load-app.ts"
+
+export async function runRoutes(args: ParsedArgs): Promise<number> {
+  const entry = await resolveEntry(args.positional)
+  if (!entry) {
+    console.error("error: no entry file found (tried src/app.ts, app.ts, src/index.ts)")
+    return 2
+  }
+  const app = await loadApp(entry)
+  if (!app) {
+    console.error(`error: no default/named 'app' export in ${entry}`)
+    return 2
+  }
+  const list = app.routeList.map((r) => ({
+    method: r.method,
+    path: r.path,
+    name: r.meta.name,
+    tags: r.meta.tags ?? [],
+    mcp: Boolean(r.meta.mcp),
+  }))
+  if (isJson(args.flags)) {
+    console.log(JSON.stringify(list, null, 2))
+    return 0
+  }
+  printTable(list, app.routeList)
+  return 0
+}
+
+function printTable(
+  list: readonly { method: string; path: string; name: string | undefined; mcp: boolean }[],
+  routes: readonly Route[],
+): void {
+  const methodW = Math.max(6, ...list.map((r) => r.method.length))
+  const pathW = Math.max(4, ...list.map((r) => r.path.length))
+  console.log(`${"method".padEnd(methodW)}  ${"path".padEnd(pathW)}  name / meta`)
+  console.log(`${"".padEnd(methodW, "-")}  ${"".padEnd(pathW, "-")}  -----------`)
+  for (const r of list) {
+    const mcpTag = r.mcp ? "  [mcp]" : ""
+    console.log(`${r.method.padEnd(methodW)}  ${r.path.padEnd(pathW)}  ${r.name ?? ""}${mcpTag}`)
+  }
+  console.log(`\n${routes.length} route(s)`)
+}