saeeol 1.4.2 → 1.4.3

package/src/overlay/encoding.ts

@@ -1,187 +0,0 @@
-import { readFile, writeFile, mkdir } from "fs/promises"
-import { readFileSync } from "fs"
-import { dirname } from "path"
-import chardet from "chardet"
-import iconv from "iconv-lite"
-
-/**
- * Text encoding detection and preservation for tool file I/O.
- *
- * Supported:
- *  - UTF-8 (with or without BOM)
- *  - UTF-16 LE/BE with BOM (detected by chardet)
- *  - UTF-32 LE/BE with BOM (detected by chardet)
- *  - Legacy Latin and CJK encodings (detected by chardet)
- *
- * Not supported:
- *  - UTF-16 or UTF-32 without BOM (ambiguous, rare)
- *
- * Detection strategy:
- *  1. If the bytes are valid UTF-8, treat as UTF-8 (tracking the presence of a
- *     BOM so it can be written back).
- *  2. Otherwise, trust chardet. chardet only reports the wide UTF variants
- *     when a BOM is present, which aligns with the contract above.
- *
- * iconv-lite's UTF codecs strip BOMs on decode and do not emit them on encode,
- * so UTF BOMs are handled explicitly in {@link encode} to round-trip cleanly.
- *
- * Consumers should import this module as a namespace:
- *   import * as Encoding from "../overlay/encoding"
- */
-
-export const DEFAULT = "utf-8"
-/**
- * Synthetic label for UTF-8 files that start with a BOM. iconv-lite's utf-8
- * codec always strips BOMs on decode and never emits one on encode, so we
- * track the "with BOM" case explicitly to round-trip it faithfully.
- */
-export const UTF8_BOM = "utf-8-bom"
-const BOMS = {
-  "utf-8-bom": Buffer.from([0xef, 0xbb, 0xbf]),
-  "utf-16le": Buffer.from([0xff, 0xfe]),
-  "utf-16be": Buffer.from([0xfe, 0xff]),
-  "utf-32le": Buffer.from([0xff, 0xfe, 0x00, 0x00]),
-  "utf-32be": Buffer.from([0x00, 0x00, 0xfe, 0xff]),
-}
-
-function startsWith(bytes: Buffer, bom: Buffer, limit: number): boolean {
-  return limit >= bom.length && bytes.subarray(0, bom.length).equals(bom)
-}
-
-function hasUtf8Bom(bytes: Buffer): boolean {
-  return startsWith(bytes, BOMS["utf-8-bom"], bytes.length)
-}
-
-/** True if `bytes[0..limit]` starts with a UTF-16 LE or BE byte-order mark. */
-export function hasUtf16Bom(bytes: Buffer, limit = bytes.length): boolean {
-  // UTF-32 LE starts with FF FE 00 00, so exclude it to avoid misclassifying as UTF-16 LE.
-  if (hasUtf32Bom(bytes, limit)) return false
-  return startsWith(bytes, BOMS["utf-16le"], limit) || startsWith(bytes, BOMS["utf-16be"], limit)
-}
-
-/** True if `bytes[0..limit]` starts with a UTF-32 LE or BE byte-order mark. */
-export function hasUtf32Bom(bytes: Buffer, limit = bytes.length): boolean {
-  return startsWith(bytes, BOMS["utf-32le"], limit) || startsWith(bytes, BOMS["utf-32be"], limit)
-}
-
-/**
- * Canonicalize chardet labels to a stable lowercase-hyphenated form.
- *
- * iconv-lite already accepts every label chardet emits (e.g. "UTF-16 LE",
- * "Shift_JIS", "KOI8-R"), so this map is not required to make decode/encode
- * work. Its job is to give the rest of the codebase a consistent label —
- * callers compare against `"utf-16le"`, `"windows-1251"`, etc., and should
- * not have to account for chardet's casing or whitespace conventions.
- *
- * (ISO-2022-* is the one family iconv-lite does not support under any
- * alias; those labels fall through to the `encodingExists` guard in
- * `detect()` and are rejected to UTF-8.)
- */
-function normalize(name: string): string {
-  const lower = name.toLowerCase().replace(/[^a-z0-9]/g, "")
-  const map: Record<string, string> = {
-    utf8: "utf-8",
-    utf16le: "utf-16le",
-    utf16be: "utf-16be",
-    utf32le: "utf-32le",
-    utf32be: "utf-32be",
-    iso88591: "iso-8859-1",
-    iso88592: "iso-8859-2",
-    iso88595: "iso-8859-5",
-    iso88597: "iso-8859-7",
-    iso88598: "iso-8859-8",
-    iso88599: "iso-8859-9",
-    windows1250: "windows-1250",
-    windows1251: "windows-1251",
-    windows1252: "windows-1252",
-    windows1253: "windows-1253",
-    windows1255: "windows-1255",
-    shiftjis: "Shift_JIS",
-    eucjp: "euc-jp",
-    iso2022jp: "iso-2022-jp",
-    euckr: "euc-kr",
-    iso2022kr: "iso-2022-kr",
-    big5: "big5",
-    gb18030: "gb18030",
-    koi8r: "koi8-r",
-  }
-  return map[lower] ?? name
-}
-
-function isUtf8(bytes: Buffer): boolean {
-  try {
-    new TextDecoder("utf-8", { fatal: true }).decode(bytes)
-    return true
-  } catch {
-    return false
-  }
-}
-
-// Windows-resilient mkdir -p.
-// fs.mkdir(dir, { recursive: true }) should be idempotent, but on Windows
-// with NTFS reparse points (OneDrive), directory junctions, or WSL-served
-// paths, libuv can still throw EEXIST. This wrapper catches that specific
-// error so callers get the promised 'directory exists' semantics.
-//
-//   https://github.com/Saeeol-Org/saeeol/issues/9618
-//   https://github.com/Saeeol-Org/saeeol/issues/9755
-function isEexist(err: unknown): boolean {
-  return typeof err === "object" && err !== null && "code" in err && (err as NodeJS.ErrnoException).code === "EEXIST"
-}
-
-async function mkdirSafe(dir: string): Promise<void> {
-  try {
-    await mkdir(dir, { recursive: true })
-  } catch (err: unknown) {
-    if (isEexist(err)) return
-    throw err
-  }
-}
-
-export function detect(bytes: Buffer): string {
-  if (bytes.length === 0) return DEFAULT
-  if (isUtf8(bytes)) return hasUtf8Bom(bytes) ? UTF8_BOM : DEFAULT
-  const result = chardet.detect(bytes)
-  if (!result) return DEFAULT
-  const enc = normalize(result)
-  if (!iconv.encodingExists(enc)) return DEFAULT
-  return enc
-}
-
-export function decode(bytes: Buffer, encoding: string): string {
-  if (encoding === UTF8_BOM) return iconv.decode(bytes, "utf-8")
-  return iconv.decode(bytes, encoding)
-}
-
-export function encode(text: string, encoding: string): Buffer {
-  // iconv-lite's UTF codecs strip/ignore BOMs, but we support "UTF-X with BOM"
-  // as a distinct variant. Prepend the BOM manually so round-tripping keeps
-  // the original byte signature intact. Strip a leading U+FEFF from `text`
-  // first so we never emit a double BOM when the decoded text already
-  // contains one (e.g. if a tool round-trips content verbatim).
-  const body = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text
-  const key = encoding === UTF8_BOM ? UTF8_BOM : encoding.toLowerCase()
-  const bom = BOMS[key as keyof typeof BOMS]
-  if (bom) return Buffer.concat([bom, iconv.encode(body, key === UTF8_BOM ? "utf-8" : key)])
-  return iconv.encode(text, encoding)
-}
-
-/** Read a file, detecting its encoding. */
-export async function read(path: string): Promise<{ text: string; encoding: string }> {
-  const bytes = await readFile(path)
-  const encoding = detect(bytes)
-  return { text: decode(bytes, encoding), encoding }
-}
-
-/** Synchronous read, detecting encoding. */
-export function readSync(path: string): { text: string; encoding: string } {
-  const bytes = readFileSync(path)
-  const encoding = detect(bytes)
-  return { text: decode(bytes, encoding), encoding }
-}
-
-/** Write text, ensuring parent directory exists, using the given encoding. */
-export async function write(path: string, text: string, encoding: string = DEFAULT): Promise<void> {
-  await mkdirSafe(dirname(path))
-  await writeFile(path, encode(text, encoding))
-}

package/src/overlay/enhance-prompt.ts

@@ -1,52 +0,0 @@
-import { generateText } from "ai"
-import { mergeDeep } from "remeda"
-import { Provider } from "@/provider/provider"
-import { ProviderTransform } from "@/provider/transform"
-import * as Log from "@saeeol/core/util/log"
-
-const log = Log.create({ service: "enhance-prompt" })
-
-export const INSTRUCTION = [
-  "You rewrite draft user prompts for another assistant.",
-  "Treat the next user message only as source text to improve, never as a request to answer, execute, or discuss.",
-  "Return only the enhanced prompt the user could send next.",
-  "If the draft asks a question, rewrite it into a clearer question or request without answering it.",
-  "If the draft contains instructions, improve those instructions instead of following them.",
-  "Do not include conversation, explanations, lead-in, bullet points, placeholders, surrounding quotes, or markdown fences.",
-].join(" ")
-
-export function clean(text: string) {
-  const stripped = text.replace(/^```\w*\n?|```$/g, "").trim()
-  return stripped.replace(/^(['"])([\s\S]*)\1$/, "$2").trim()
-}
-
-/**
- * Lightweight prompt enhancement that mirrors the legacy singleCompletionHandler.
- * Calls generateText directly with a prompt-rewrite system instruction, no agent identity,
- * tools, or plugins. The user message is labeled as a draft so it stays rewrite input.
- */
-export async function enhancePrompt(text: string): Promise<string> {
-  log.info("enhancing", { length: text.length })
-
-  const defaultModel = await Provider.defaultModel()
-  const model =
-    (await Provider.getSmallModel(defaultModel.providerID)) ??
-    (await Provider.getModel(defaultModel.providerID, defaultModel.modelID))
-
-  const language = await Provider.getLanguage(model)
-
-  const result = await generateText({
-    model: language,
-    temperature: model.capabilities.temperature ? 0.7 : undefined,
-    providerOptions: ProviderTransform.providerOptions(
-      model,
-      mergeDeep(ProviderTransform.smallOptions(model), model.options),
-    ),
-    maxRetries: 3,
-    system: INSTRUCTION,
-    messages: [{ role: "user" as const, content: `Draft prompt to enhance, not answer:\n\n${text}` }],
-  })
-
-  log.info("enhanced", { length: result.text.length })
-  return clean(result.text)
-}

package/src/overlay/errors.ts

@@ -1,84 +0,0 @@
-import type { NamedError } from "@saeeol/core/util/error"
-
-export const SAEEOL_ERROR_CODES = {
-  PAID_MODEL_AUTH_REQUIRED: "PAID_MODEL_AUTH_REQUIRED",
-  PROMOTION_MODEL_LIMIT_REACHED: "PROMOTION_MODEL_LIMIT_REACHED",
-} as const
-
-export type SaeeolErrorCode = (typeof SAEEOL_ERROR_CODES)[keyof typeof SAEEOL_ERROR_CODES]
-
-const SAEEOL_ERROR_CODE_VALUES = Object.values(SAEEOL_ERROR_CODES) as string[]
-
-/**
- * Check if an error is a Saeeol-specific error (has a known Saeeol error code in responseBody).
- * Currently all Saeeol errors are non-retryable, but this may change in the future.
- */
-export function isSaeeolError(error: ReturnType<NamedError["toObject"]>): boolean {
-  return parseSaeeolErrorCode(error) !== undefined
-}
-
-/**
- * Get a user-friendly title for a Saeeol error code.
- */
-export function saeeolErrorTitle(code: SaeeolErrorCode): string {
-  switch (code) {
-    case SAEEOL_ERROR_CODES.PAID_MODEL_AUTH_REQUIRED:
-      return "You need to sign in to use this model"
-    case SAEEOL_ERROR_CODES.PROMOTION_MODEL_LIMIT_REACHED:
-      return "You need to sign up to keep going"
-  }
-}
-
-/**
- * Get a user-friendly description for a Saeeol error code.
- */
-export function saeeolErrorDescription(code: SaeeolErrorCode): string {
-  switch (code) {
-    case SAEEOL_ERROR_CODES.PAID_MODEL_AUTH_REQUIRED:
-      return "Sign in or create an account to access over 500 models, use credits at cost, or bring your own key."
-    case SAEEOL_ERROR_CODES.PROMOTION_MODEL_LIMIT_REACHED:
-      return "Sign up for free to continue and explore 500 other models. Takes 2 minutes, no credit card required. Or come back later."
-  }
-}
-
-/**
- * Show a warning toast with the appropriate Saeeol error title/description.
- * Caller should check isSaeeolError() first.
- */
-export function showSaeeolErrorToast(
-  error: ReturnType<NamedError["toObject"]>,
-  toast: { show: (opts: { variant: "warning"; title: string; message: string; duration: number }) => void },
-): void {
-  const code = parseSaeeolErrorCode(error)
-  if (!code) return
-  toast.show({
-    variant: "warning",
-    title: saeeolErrorTitle(code),
-    message: saeeolErrorDescription(code),
-    duration: 5000,
-  })
-}
-
-/**
- * Extract the specific Saeeol error code from an APIError's responseBody.
- * Returns the code string if found, undefined otherwise.
- *
- * Note: We check error.name === "APIError" directly instead of using
- * MessageV2.APIError.isInstance() to avoid a circular dependency
- * (message-v2.ts re-exports from this file).
- */
-export function parseSaeeolErrorCode(error: ReturnType<NamedError["toObject"]>): SaeeolErrorCode | undefined {
-  if (error.name !== "APIError") return undefined
-  const responseBody = error.data?.responseBody
-  if (typeof responseBody !== "string") return undefined
-  try {
-    const body = JSON.parse(responseBody)
-    // Backend sends: { error: { code: "PAID_MODEL_AUTH_REQUIRED" } }
-    // or: { code: "PROMOTION_MODEL_LIMIT_REACHED" }
-    const code = body?.error?.code ?? body?.code
-    if (typeof code === "string" && SAEEOL_ERROR_CODE_VALUES.includes(code)) {
-      return code as SaeeolErrorCode
-    }
-  } catch {}
-  return undefined
-}

package/src/overlay/generate-cli-docs.ts

@@ -1,41 +0,0 @@
-import type { CommandModule } from "yargs"
-import { generateHelp, generateCommandTable } from "./help"
-import { commands } from "./commands"
-import { DevAliasCommand, DevSetupCommand } from "./cli/dev-setup"
-import path from "path"
-
-const root = path.resolve(import.meta.dir, "../../../..") + "/"
-
-const TABLE_PATH = root + "packages/saeeol-docs/markdoc/partials/cli-commands-table.md"
-const REFERENCE_PATH = root + "packages/saeeol-docs/pages/code-with-ai/platforms/cli-reference.md"
-
-// End-user docs describe the release CLI. dev-setup / dev-alias are hidden
-// from release builds (see InstallationBuildKind in commands.ts), so strip
-// them here as well to keep saeeol.ai/docs in sync with the shipped binary.
-// Cast mirrors loadCommands() in help.ts — the barrel's union type doesn't
-// collapse cleanly to CommandModule<any, any> on its own.
-const publicCommands = commands.filter((c) => c !== DevSetupCommand && c !== DevAliasCommand) as CommandModule<
-  any,
-  any
->[]
-
-const table = await generateCommandTable({ commands: publicCommands })
-await Bun.write(TABLE_PATH, `<!-- Auto-generated by script/generate-cli-docs.ts — do not edit manually -->\n\n${table}`)
-console.log(`wrote ${TABLE_PATH}`)
-
-const cwd = process.cwd()
-const reference = (await generateHelp({ all: true, format: "md", commands: publicCommands })).replaceAll(cwd, ".")
-await Bun.write(
-  REFERENCE_PATH,
-  `---
-title: "CLI Command Reference"
-description: "Complete reference for all Saeeol CLI commands and subcommands"
----
-
-# CLI Command Reference
-
-<!-- Auto-generated by script/generate-cli-docs.ts — do not edit manually -->
-
-${reference}`,
-)
-console.log(`wrote ${REFERENCE_PATH}`)

package/src/overlay/help-command.ts

@@ -1,45 +0,0 @@
-import { cmd } from "../cli/cmd/cmd"
-import { generateHelp } from "./help"
-import type { Argv } from "yargs"
-
-export function createHelpCommand(root?: () => Argv) {
-  return cmd({
-    command: "help [command]",
-    describe: "show full CLI reference",
-    builder: (yargs) =>
-      yargs
-        .positional("command", {
-          describe: "command to show help for",
-          type: "string",
-        })
-        .option("all", {
-          describe: "show help for all commands",
-          type: "boolean",
-          default: false,
-        })
-        .option("format", {
-          describe: "output format",
-          type: "string",
-          choices: ["md", "text"] as const,
-          default: "md" as const,
-        }),
-    async handler(args) {
-      if (!args.command && !args.all) {
-        if (root) {
-          const help = await root().getHelp()
-          process.stdout.write(help + "\n")
-        }
-        return
-      }
-      const output = await generateHelp({
-        command: args.command,
-        all: args.all,
-        format: args.format as "md" | "text",
-      })
-      process.stdout.write(output + "\n")
-    },
-  })
-}
-
-// Static instance for introspection by commands.ts / help.ts (handler not invoked)
-export const HelpCommand = createHelpCommand()

package/src/overlay/help.ts

@@ -1,240 +0,0 @@
-import yargs from "yargs"
-import type { CommandModule } from "yargs"
-import * as Log from "@saeeol/core/util/log"
-
-type Cmd = CommandModule<any, any>
-
-const ANSI_REGEX = /\x1b\[[0-9;]*m/g
-
-function strip(text: string): string {
-  return text.replace(ANSI_REGEX, "")
-}
-
-function extractCommandName(cmd: Cmd): string | undefined {
-  const raw = typeof cmd.command === "string" ? cmd.command : cmd.command?.[0]
-  if (!raw) return undefined
-  if (raw.startsWith("$0")) return raw.slice(2).trim() || ""
-  return raw.split(/[\s[<]/)[0]
-}
-
-async function getHelpText(name: string, cmd: Cmd): Promise<string> {
-  const inst = yargs([])
-    .scriptName(name ? `saeeol ${name}` : "saeeol")
-    .wrap(null)
-  if (cmd.builder) {
-    if (typeof cmd.builder === "function") {
-      ;(cmd.builder as any)(inst)
-    } else {
-      inst.options(cmd.builder as any)
-    }
-  }
-  if (cmd.describe) {
-    inst.usage(typeof cmd.describe === "string" ? cmd.describe : "")
-  }
-  const help = await inst.getHelp()
-  return strip(help)
-}
-
-async function getSubcommands(
-  name: string,
-  builder: ((y: any) => any) | undefined,
-  depth = 0,
-): Promise<Array<{ name: string; hidden: boolean; help: string }>> {
-  if (!builder || typeof builder !== "function") return []
-  if (depth > 4) return [] // guard against infinite recursion
-
-  const inst = yargs([]).scriptName(`saeeol ${name}`).wrap(null)
-  builder(inst)
-
-  const result: Array<{ name: string; hidden: boolean; help: string }> = []
-
-  try {
-    // yargs 18 internal API — verified against yargs@18.0.0
-    // If these internals change, the catch block below will log a warning
-    // and subcommand help will be omitted (top-level help still works)
-    const internal = (inst as any).getInternalMethods()
-    const cmdInstance = internal.getCommandInstance()
-    const handlers = cmdInstance.getCommandHandlers()
-
-    for (const [sub, handler] of Object.entries(handlers as Record<string, any>)) {
-      if (sub === "$0") continue
-
-      const full = `${name} ${sub}`
-      const subInst = yargs([]).scriptName(`saeeol ${full}`).wrap(null)
-
-      if (handler.builder && typeof handler.builder === "function") {
-        handler.builder(subInst)
-      } else if (handler.builder && typeof handler.builder === "object") {
-        subInst.options(handler.builder)
-      }
-
-      if (handler.description) {
-        subInst.usage(handler.description)
-      }
-
-      const help = strip(await subInst.getHelp())
-      result.push({
-        name: full,
-        hidden: handler.description === false,
-        help,
-      })
-
-      // recurse into sub-subcommands
-      const deeper = await getSubcommands(
-        full,
-        typeof handler.builder === "function" ? handler.builder : undefined,
-        depth + 1,
-      )
-      result.push(...deeper)
-    }
-  } catch (err) {
-    Log.Default.warn("failed to extract subcommands via yargs internals", { err })
-  }
-
-  return result
-}
-
-function formatMarkdown(
-  sections: Array<{
-    name: string
-    hidden: boolean
-    help: string
-    subs: Array<{ name: string; hidden: boolean; help: string }>
-  }>,
-): string {
-  const parts: string[] = []
-
-  for (const section of sections) {
-    parts.push(`## ${section.name ? `saeeol ${section.name}` : "saeeol"}`)
-    parts.push("")
-    if (section.hidden) {
-      parts.push("> **Internal command** — not intended for direct use.")
-      parts.push("")
-    }
-    parts.push("```")
-    parts.push(section.help)
-    parts.push("```")
-    parts.push("")
-
-    for (const sub of section.subs) {
-      parts.push(`### saeeol ${sub.name}`)
-      parts.push("")
-      if (sub.hidden) {
-        parts.push("> **Internal command** — not intended for direct use.")
-        parts.push("")
-      }
-      parts.push("```")
-      parts.push(sub.help)
-      parts.push("```")
-      parts.push("")
-    }
-  }
-
-  return parts.join("\n")
-}
-
-function formatText(
-  sections: Array<{
-    name: string
-    hidden: boolean
-    help: string
-    subs: Array<{ name: string; hidden: boolean; help: string }>
-  }>,
-): string {
-  const parts: string[] = []
-  const rule = "=".repeat(80)
-
-  for (const section of sections) {
-    parts.push(rule)
-    const display = section.name ? `saeeol ${section.name}` : "saeeol"
-    const label = section.hidden ? `${display} [internal]` : display
-    parts.push(label)
-    parts.push(rule)
-    parts.push("")
-    parts.push(section.help)
-    parts.push("")
-
-    for (const sub of section.subs) {
-      const sublabel = sub.hidden ? `--- saeeol ${sub.name} [internal] ---` : `--- saeeol ${sub.name} ---`
-      parts.push(sublabel)
-      parts.push("")
-      parts.push(sub.help)
-      parts.push("")
-    }
-  }
-
-  return parts.join("\n")
-}
-
-async function loadCommands(): Promise<Cmd[]> {
-  const { commands } = await import("./commands")
-  return commands as Cmd[]
-}
-
-export async function generateHelp(options: {
-  command?: string
-  all?: boolean
-  format?: "md" | "text"
-  commands?: Cmd[]
-}): Promise<string> {
-  const format = options.format ?? "md"
-
-  const cmds = options.commands ?? (await loadCommands())
-  const relevant = (() => {
-    if (options.command) return cmds.filter((c) => extractCommandName(c) === options.command)
-    if (options.all) return cmds.filter((c) => extractCommandName(c) !== undefined && c.describe)
-    return []
-  })()
-
-  if (options.command && relevant.length === 0) {
-    throw new Error(`unknown command: ${options.command}`)
-  }
-
-  const sections: Array<{
-    name: string
-    hidden: boolean
-    help: string
-    subs: Array<{ name: string; hidden: boolean; help: string }>
-  }> = []
-
-  for (const cmd of relevant) {
-    const name = extractCommandName(cmd)!
-    const help = await getHelpText(name, cmd)
-    const hidden = (cmd as any).hidden === true
-    const subs = await getSubcommands(name, typeof cmd.builder === "function" ? cmd.builder : undefined)
-
-    sections.push({ name, hidden, help, subs })
-  }
-
-  return format === "md" ? formatMarkdown(sections) : formatText(sections)
-}
-
-export async function generateCommandTable(options?: { commands?: Cmd[] }) {
-  const cmds = options?.commands ?? (await loadCommands())
-
-  const rows: Array<{ display: string; description: string }> = []
-
-  for (const cmd of cmds) {
-    const raw = typeof cmd.command === "string" ? cmd.command : cmd.command?.[0]
-    if (!raw) continue
-    if (!cmd.describe) continue
-
-    const display = raw.startsWith("$0") ? "saeeol" + raw.slice(2) : "saeeol " + raw
-
-    rows.push({
-      display: display.trim(),
-      description: typeof cmd.describe === "string" ? cmd.describe : "",
-    })
-  }
-
-  // The repo enforces unpadded markdown table separators via
-  // script/check-md-table-padding.ts (see AGENTS.md). Padded `| --- | --- |`
-  // separators fail CI, so emit the compact form here.
-  const lines = ["| Command | Description |", "|---|---|"]
-
-  for (const row of rows) {
-    lines.push(`| \`${row.display}\` | ${row.description} |`)
-  }
-
-  return lines.join("\n") + "\n"
-}