github-search-cli 9.6.0 → 9.7.1

package/src/deepdive.ts

@@ -1,6 +1,5 @@
 /** Repo deep-dive — fetch and format rich repo details. */
 import type { Repo } from "./types";
-import { NetworkError } from "./errors";
 
 const USER_AGENT = "ghfind/1.0";
 
@@ -10,6 +9,119 @@ function buildHeaders(token?: string): Record<string, string> {
   return headers;
 }
 
+// ─── Repo ref parsing (shared by the CLI deep-dive and the MCP server) ─
+
+const REPO_REF_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+
+/**
+ * Parse a repo reference ("owner/name") into its parts. Tolerates a trailing
+ * `.git` and a leading `@`. Throws with a user-facing message for anything else.
+ */
+export function parseRepoRef(input: string): { owner: string; name: string } {
+  const fullName = input
+    .trim()
+    .replace(/\.git$/, "")
+    .replace(/^@/, "");
+  if (!REPO_REF_RE.test(fullName)) {
+    throw new Error(
+      `"${input}" is not a repo name — use owner/name, e.g. facebook/react.`,
+    );
+  }
+  const [owner, name] = fullName.split("/");
+  return { owner, name };
+}
+
+/** Minimal Repo for deep-dive (the fetchers only read owner/name). */
+export function repoFromRef(fullName: string): Repo {
+  const { owner, name } = parseRepoRef(fullName);
+  return {
+    id: 0,
+    fullName: `${owner}/${name}`,
+    name,
+    owner,
+    description: null,
+    url: `https://github.com/${owner}/${name}`,
+    stars: 0,
+    forks: 0,
+    watchers: 0,
+    language: null,
+    topics: [],
+    archived: false,
+    isFork: false,
+    private: false,
+    createdAt: "",
+    updatedAt: "",
+    pushedAt: "",
+    score: 0,
+  };
+}
+
+/**
+ * Resolve a repo ref to a real Repo by fetching canonical metadata from the
+ * GitHub API. Returns a stub via repoFromRef when the metadata fetch fails
+ * (offline, rate limit) — the ref is still validated first. Deep-dive
+ * sub-fetches tolerate missing data either way.
+ */
+export async function resolveRepoFromRef(
+  fullName: string,
+  token?: string,
+): Promise<Repo> {
+  const ref = parseRepoRef(fullName); // throws for malformed refs
+  const canonical = `${ref.owner}/${ref.name}`;
+  try {
+    const res = await fetch(`https://api.github.com/repos/${canonical}`, {
+      headers: buildHeaders(token),
+    });
+    if (res.status === 404) {
+      throw new Error(`Repo not found: ${canonical}`);
+    }
+    if (res.ok) {
+      const api = (await res.json()) as {
+        description: string | null;
+        html_url: string;
+        stargazers_count: number;
+        forks_count: number;
+        subscribers_count?: number;
+        language: string | null;
+        topics?: string[];
+        archived: boolean;
+        fork: boolean;
+        created_at: string;
+        updated_at: string;
+        pushed_at: string;
+      };
+      return {
+        id: 0,
+        fullName: canonical,
+        name: ref.name,
+        owner: ref.owner,
+        description: api.description,
+        url: api.html_url,
+        stars: api.stargazers_count ?? 0,
+        forks: api.forks_count ?? 0,
+        watchers: api.subscribers_count ?? 0,
+        language: api.language,
+        topics: api.topics ?? [],
+        archived: api.archived ?? false,
+        isFork: api.fork ?? false,
+        private: false,
+        createdAt: api.created_at ?? "",
+        updatedAt: api.updated_at ?? "",
+        pushedAt: api.pushed_at ?? "",
+        score: 0,
+      };
+    }
+  } catch (err) {
+    // Let the not-found error propagate; only network/parse failures degrade
+    // to the stub below.
+    if (err instanceof Error && err.message.startsWith("Repo not found")) {
+      throw err;
+    }
+    // Fall through to the stub.
+  }
+  return repoFromRef(canonical);
+}
+
 /** Language breakdown: { [lang]: bytes } */
 type LanguageMap = Record<string, number>;
 
@@ -27,11 +139,31 @@ export interface DeepDiveData {
   readme: string;
 }
 
-/** Fetch all deep-dive data for a repo. Returns formatted sections. */
-export async function fetchDeepDive(
+/** Structured deep-dive payload — JSON-ready (for `ghfind deep-dive --json`). */
+export interface DeepDiveJson {
+  repo: {
+    fullName: string;
+    url: string;
+    description: string | null;
+    stars: number;
+    forks: number;
+    language: string | null;
+    topics: string[];
+  };
+  /** Language breakdown sorted by bytes, descending. */
+  languages: { name: string; bytes: number; percent: number }[];
+  contributors: { login: string; contributions: number }[];
+  /** Raw README markdown (capped at README_MAX_CHARS). */
+  readme: string;
+}
+
+const README_MAX_CHARS = 5_000;
+
+/** Fetch deep-dive data as structured JSON: language percents, contributors, raw README. */
+export async function fetchDeepDiveRaw(
   repo: Repo,
   token?: string,
-): Promise<DeepDiveData> {
+): Promise<DeepDiveJson> {
   const headers = buildHeaders(token);
 
   const [languagesRes, contributorsRes] = await Promise.all([
@@ -60,22 +192,64 @@ export async function fetchDeepDive(
     }
   }
 
+  const langEntries: [string, number][] = languagesRes.ok
+    ? Object.entries(
+        (await languagesRes.json().catch(() => ({}))) as LanguageMap,
+      )
+    : [];
+  const totalBytes = langEntries.reduce((s, [, v]) => s + v, 0);
+  const contributors: Contributor[] = contributorsRes.ok
+    ? ((await contributorsRes.json().catch(() => [])) as Contributor[])
+    : [];
+
+  return {
+    repo: {
+      fullName: repo.fullName,
+      url: repo.url,
+      description: repo.description,
+      stars: repo.stars,
+      forks: repo.forks,
+      language: repo.language,
+      topics: repo.topics,
+    },
+    languages: langEntries
+      .sort(([, a], [, b]) => b - a)
+      .map(([name, bytes]) => ({
+        name,
+        bytes,
+        percent: totalBytes > 0 ? (bytes / totalBytes) * 100 : 0,
+      })),
+    contributors: contributors.map((c) => ({
+      login: c.login,
+      contributions: c.contributions,
+    })),
+    readme: readmeText.slice(0, README_MAX_CHARS),
+  };
+}
+
+/** JSON string for `ghfind deep-dive --json`. */
+export function buildDeepDiveJson(data: DeepDiveJson): string {
+  return JSON.stringify(data, null, 2);
+}
+
+/** Format structured deep-dive data into display sections. */
+export function buildDeepDiveData(repo: Repo, raw: DeepDiveJson): DeepDiveData {
   return {
     summary: formatSummary(repo),
-    languages: formatLanguages(
-      languagesRes.ok
-        ? ((await languagesRes.json().catch(() => ({}))) as LanguageMap)
-        : {},
-    ),
-    contributors: formatContributors(
-      contributorsRes.ok
-        ? ((await contributorsRes.json().catch(() => [])) as Contributor[])
-        : [],
-    ),
-    readme: formatReadme(readmeText),
+    languages: formatLanguages(raw.languages),
+    contributors: formatContributors(raw.contributors),
+    readme: formatReadme(raw.readme),
   };
 }
 
+/** Fetch all deep-dive data for a repo. Returns formatted sections. */
+export async function fetchDeepDive(
+  repo: Repo,
+  token?: string,
+): Promise<DeepDiveData> {
+  return buildDeepDiveData(repo, await fetchDeepDiveRaw(repo, token));
+}
+
 function formatSummary(repo: Repo): string {
   const lines = [
     ` ${repo.fullName}`,
@@ -87,17 +261,14 @@ function formatSummary(repo: Repo): string {
   return lines.filter(Boolean).join("\n");
 }
 
-function formatLanguages(langs: LanguageMap): string {
-  const entries = Object.entries(langs);
-  if (entries.length === 0) return "  (no language data)";
-  const total = entries.reduce((s, [, v]) => s + v, 0);
+function formatLanguages(langs: DeepDiveJson["languages"]): string {
+  if (langs.length === 0) return "  (no language data)";
   const barW = 20;
-  return entries
-    .sort(([, a], [, b]) => b - a)
+  return langs
     .slice(0, 8)
-    .map(([name, bytes]) => {
-      const pct = ((bytes / total) * 100).toFixed(1);
-      const filled = Math.round((bytes / total) * barW);
+    .map(({ name, percent }) => {
+      const pct = percent.toFixed(1);
+      const filled = Math.round((percent / 100) * barW);
       const bar = "█".repeat(filled) + "░".repeat(barW - filled);
       return `  ${name.padEnd(16)} ${bar} ${pct}%`;
     })

package/src/doctor.ts

@@ -5,11 +5,11 @@
  * Runs a battery of checks and prints a PASS / WARN / FAIL report, then exits
  * non-zero if any FAIL check was detected.
  */
-import { existsSync, readFileSync, mkdirSync } from "fs";
-import { spawnSync } from "child_process";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { homedir, platform, arch } from "os";
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir, platform, arch } from "node:os";
 import { loadConfig, configPath, stateDir, cacheDir } from "./config";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -31,9 +31,14 @@ function add(status: CheckStatus, label: string, detail: string): void {
 function run(
   cmd: string,
   args: string[],
+  opts: { shell?: boolean; timeout?: number } = {},
 ): { status: number | null; stdout: string; stderr: string } {
   try {
-    const res = spawnSync(cmd, args, { encoding: "utf8", timeout: 15000 });
+    const res = spawnSync(cmd, args, {
+      encoding: "utf8",
+      timeout: 15000,
+      ...opts,
+    });
     return {
       status: res.status,
       stdout: res.stdout ?? "",
@@ -123,13 +128,13 @@ function checkSystemBun(bundledOk: boolean): void {
     add(
       "WARN",
       "System Bun",
-      "No \`bun\` on PATH. Bundled Bun is working, so this is only a fallback.",
+      "No `bun` on PATH. Bundled Bun is working, so this is only a fallback.",
     );
   } else {
     add(
       "FAIL",
       "System Bun",
-      "No \`bun\` on PATH. Install it: curl -fsSL https://bun.sh/install | bash",
+      "No `bun` on PATH. Install it: curl -fsSL https://bun.sh/install | bash",
     );
   }
 }
@@ -236,6 +241,136 @@ function checkDirs(): void {
   }
 }
 
+const PKG_NAME = "github-search-cli";
+const BIN_NAME = "ghfind";
+
+function runningVersion(): string {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(PKG_DIR, "package.json"), "utf8"),
+    ) as { version?: string };
+    return pkg.version ?? "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Best-effort version of the install that owns a `ghfind` shim on PATH.
+ * Prefers reading the sibling package.json (cheap, exact); falls back to
+ * executing the shim with `--version` (handles bun/unknown layouts).
+ */
+export function installVersionAt(
+  shimPath: string,
+): { version: string; dir: string } | null {
+  const dir = dirname(shimPath);
+  // npm layouts: <prefix>/node_modules/<pkg> (win) or <prefix>/lib/node_modules/<pkg> (unix)
+  for (const ancestor of [dir, dirname(dir)]) {
+    for (const sub of ["node_modules", join("lib", "node_modules")]) {
+      const pkgJson = join(ancestor, sub, PKG_NAME, "package.json");
+      if (existsSync(pkgJson)) {
+        try {
+          const pkg = JSON.parse(readFileSync(pkgJson, "utf8")) as {
+            version?: string;
+          };
+          return { version: pkg.version ?? "", dir: dirname(pkgJson) };
+        } catch {
+          // fall through to shim execution
+        }
+      }
+    }
+  }
+  // .cmd/.bat shims require shell:true under Node (EINVAL otherwise); the
+  // package.json read above already covered the common npm layouts.
+  const res = run(shimPath, ["--version"], {
+    shell: platform() === "win32",
+    timeout: 10000,
+  });
+  const m = /\d+\.\d+\.\d+/.exec(res.stdout);
+  return m ? { version: m[0], dir } : null;
+}
+
+/**
+ * Detect stale/shadowing global installs: multiple `ghfind` binaries on PATH
+ * resolving to different versions means the shell may keep launching an old
+ * copy even after a successful update — the exact "updater says OK but
+ * nothing changed" trap. Warns and names the offending prefixes.
+ */
+function checkInstallShadowing(): void {
+  const isWin = platform() === "win32";
+  const res = isWin ? run("where", [BIN_NAME]) : run("which", ["-a", BIN_NAME]);
+  const shims = [
+    ...new Set(
+      res.stdout
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0),
+    ),
+  ];
+  if (shims.length === 0) {
+    add("WARN", "Global installs", `${BIN_NAME} not found on PATH.`);
+    return;
+  }
+  const running = runningVersion();
+  const norm = (p: string) => (isWin ? p.replace(/\\/g, "/").toLowerCase() : p);
+  const seenDirs = new Set<string>();
+  const stale: string[] = [];
+  let knownCount = 0;
+  let staleVersion = "";
+  let staleDir = "";
+
+  for (const shim of shims) {
+    const info = installVersionAt(shim);
+    // Group shims that live in the same install (ghfind + ghfind.cmd + ghfind.ps1)
+    const dirKey = norm(dirname(shim));
+    if (seenDirs.has(dirKey)) continue;
+    seenDirs.add(dirKey);
+    knownCount++;
+    const isRunningInstall = info !== null && norm(info.dir) === norm(PKG_DIR);
+    if (
+      !isRunningInstall &&
+      info !== null &&
+      running &&
+      info.version !== running
+    ) {
+      stale.push(`${dirname(shim)} (v${info.version} ≠ running v${running})`);
+      staleVersion = info.version;
+      staleDir = dirname(shim);
+    }
+  }
+
+  if (stale.length > 0 && knownCount > 1) {
+    // Shadowing needs ≥2 installs: the shell can keep launching an old copy
+    // while updates land in another prefix.
+    add(
+      "WARN",
+      "Global installs",
+      `${knownCount} install(s) on PATH; stale copies shadowing updates → ${stale.join("; ")}. Remove with: npm uninstall -g ${PKG_NAME} --prefix <dir>`,
+    );
+  } else if (stale.length > 0) {
+    // Single install whose version differs from the running copy — normal
+    // when developing from source (running vNEWER than the published one).
+    // Uninstalling it would be harmful advice.
+    add(
+      "PASS",
+      "Global installs",
+      `v${staleVersion} at ${staleDir} (running v${running || "?"} from source/build) — single install, nothing shadowed.`,
+    );
+  } else if (knownCount > 1) {
+    add(
+      "PASS",
+      "Global installs",
+      `${knownCount} install(s) on PATH, all v${running || "?"}.`,
+    );
+  } else {
+    add(
+      "PASS",
+      "Global installs",
+      `v${running || "?"} at ${dirname(shims[0])}.`,
+    );
+  }
+}
+
 function printReport(): void {
   // Respect NO_COLOR (https://no-color.org/): plain text when set (any value,
   // including the empty string) or when stdout is not a TTY.
@@ -284,6 +419,7 @@ export async function runDoctor(): Promise<void> {
   checkConfig();
   checkGithubToken();
   checkDirs();
+  checkInstallShadowing();
   printReport();
 
   const hasFail = results.some((r) => r.status === "FAIL");

package/src/error-report.ts

@@ -10,8 +10,8 @@ import {
   arch as osArch,
   version as nodeVersion,
   versions as nodeVersions,
-} from "process";
-import { spawn } from "child_process";
+} from "node:process";
+import { spawn } from "node:child_process";
 import { getVersion } from "./version";
 
 // ponytail: in bun, process.platform is a string property; in node, same.
@@ -43,6 +43,7 @@ export function formatErrorBody(
   context: { command: string; argv: string[] },
 ): string {
   const e = err instanceof Error ? err : new Error(String(err));
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: strips ANSI color escapes from stack traces
   const stack = (e.stack ?? "(no stack)").replace(/\u001b\[[0-9;]*m/g, "");
   const message = (e.message || "(no message)").slice(0, 500);
   const cmd = `${context.command} ${context.argv.join(" ")}`.trim();
@@ -105,14 +106,19 @@ function tryOpenUrl(url: string): boolean {
   try {
     const p = osPlatform;
     if (typeof Bun !== "undefined") {
-      if (p === "win32") Bun.spawn(["cmd", "/c", "start", "", url]);
-      else if (p === "darwin") Bun.spawn(["open", url]);
+      if (p === "win32") {
+        // explorer.exe, not `cmd /c start` — cmd splits the URL at the first
+        // unquoted `&` (query separator) and runs the rest as a command,
+        // truncating every pre-filled issue URL. See src/open-url.ts.
+        Bun.spawn(["explorer", url]);
+      } else if (p === "darwin") Bun.spawn(["open", url]);
       else Bun.spawn(["xdg-open", url]);
       return true;
     }
     // Node fallback — use child_process.spawn detached so it survives exit
-    const cmd = p === "win32" ? "cmd" : p === "darwin" ? "open" : "xdg-open";
-    const args = p === "win32" ? ["/c", "start", "", url] : [url];
+    const cmd =
+      p === "win32" ? "explorer" : p === "darwin" ? "open" : "xdg-open";
+    const args = [url];
     const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
     child.unref();
     return true;
@@ -142,11 +148,11 @@ export function reportError(
   console.error("");
   const opened = tryOpenUrl(url);
   if (opened) {
-    console.error("  → Opened: " + url);
+    console.error(`  → Opened: ${url}`);
   } else {
     console.error("  Copy this URL to file a bug report:");
     console.error("");
-    console.error("    " + url);
+    console.error(`    ${url}`);
   }
   console.error("");
   return url;

package/src/export.ts

@@ -1,7 +1,7 @@
 /**
  * Export — format repos as JSON, CSV, Markdown, or plain text.
  */
-import { writeFileSync } from "fs";
+import { writeFileSync } from "node:fs";
 import type { Repo } from "./types";
 
 export type ExportFormat = "json" | "csv" | "markdown" | "text";

package/src/history.ts

@@ -2,7 +2,7 @@
  * Persistent search history — append-only JSONL with rotation.
  */
 import type { HistoryEntry } from "./types";
-import { readJSONL, appendJSONL, writeJSON, writeRaw } from "./storage";
+import { readJSONL, appendJSONL, writeRaw } from "./storage";
 
 const HISTORY_FILE = "history.jsonl";
 const MAX_ENTRIES = 500;
@@ -37,10 +37,10 @@ export function deleteHistoryEntry(index: number): void {
   );
   writeRaw(
     HISTORY_FILE,
-    remaining
+    `${remaining
       .reverse()
       .map((e) => JSON.stringify(e))
-      .join("\n") + "\n",
+      .join("\n")}\n`,
   );
 }
 
@@ -56,10 +56,10 @@ export function rotateHistory(): void {
   const trimmed = entries.slice(0, MAX_ENTRIES);
   writeRaw(
     HISTORY_FILE,
-    trimmed
+    `${trimmed
       .reverse()
       .map((e) => JSON.stringify(e))
-      .join("\n") + "\n",
+      .join("\n")}\n`,
   );
 }
 

package/src/init.ts

@@ -3,7 +3,7 @@
  *
  * ponytail: simple stdin prompts, no curses/readline UI.
  */
-import { createInterface } from "readline";
+import { createInterface } from "node:readline";
 import { saveConfig } from "./config";
 import { isLikelyGithubToken } from "./login";
 import { listThemes } from "./themes";
@@ -44,7 +44,7 @@ export async function runInitWizard(): Promise<void> {
     defaultSort: (["best-match", "stars", "updated", "forks"].includes(sortStr)
       ? sortStr
       : "best-match") as SortStrategy,
-    defaultLimit: Math.min(100, Math.max(10, parseInt(limitStr) || 50)),
+    defaultLimit: Math.min(100, Math.max(10, parseInt(limitStr, 10) || 50)),
     theme: themes.includes(themeStr) ? themeStr : themes[0],
     cacheTtlSeconds: 300,
     defaultTab: "search",

package/src/login.ts

@@ -6,10 +6,10 @@
  * used by `ghfind init` (~/.config/ghfind/config.json). `GITHUB_TOKEN` in the
  * environment always takes precedence at runtime (see src/config.ts).
  */
-import { createInterface } from "readline";
-import { homedir } from "os";
-import { join } from "path";
-import { existsSync, readFileSync } from "fs";
+import { createInterface } from "node:readline";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 import { loadConfig, saveConfig, configPath } from "./config";
 import type { Config } from "./types";
 

package/src/markdown-render.ts

@@ -26,12 +26,12 @@ export function renderMarkdown(md: string, opts: RenderOptions = {}): string {
     if (codeLines.length === 0) return;
     const maxLen = Math.max(...codeLines.map((l) => l.length), codeLang.length);
     const barW = Math.min(maxLen + 4, width - 2);
-    out.push("┌" + "─".repeat(barW) + "┐");
-    if (codeLang) out.push("│ " + codeLang.padEnd(barW - 1) + "│");
+    out.push(`┌${"─".repeat(barW)}┐`);
+    if (codeLang) out.push(`│ ${codeLang.padEnd(barW - 1)}│`);
     for (const cl of codeLines) {
-      out.push("│ " + cl.padEnd(barW - 1) + "│");
+      out.push(`│ ${cl.padEnd(barW - 1)}│`);
     }
-    out.push("└" + "─".repeat(barW) + "┘");
+    out.push(`└${"─".repeat(barW)}┘`);
     out.push("");
     codeLines = [];
     codeLang = "";
@@ -54,16 +54,16 @@ export function renderMarkdown(md: string, opts: RenderOptions = {}): string {
     const totalW = colW.reduce((a, b) => a + b, 0) + colCount * 3 - 1;
     if (totalW > width) {
       for (const row of dataRows) {
-        out.push("  " + row.map((c) => c.trim()).join(" │ "));
+        out.push(`  ${row.map((c) => c.trim()).join(" │ ")}`);
       }
     } else {
-      const sep = "┌" + colW.map((w) => "─".repeat(w + 2)).join("┬") + "┐";
-      const mid = "├" + colW.map((w) => "─".repeat(w + 2)).join("┼") + "┤";
-      const end = "└" + colW.map((w) => "─".repeat(w + 2)).join("┴") + "┘";
+      const sep = `┌${colW.map((w) => "─".repeat(w + 2)).join("┬")}┐`;
+      const mid = `├${colW.map((w) => "─".repeat(w + 2)).join("┼")}┤`;
+      const end = `└${colW.map((w) => "─".repeat(w + 2)).join("┴")}┘`;
       out.push(sep);
       dataRows.forEach((row, i) => {
         const cells = colW.map((w, ci) => (row[ci] ?? "").trim().padEnd(w));
-        out.push("│ " + cells.map((c) => ` ${c} `).join("│") + "│");
+        out.push(`│ ${cells.map((c) => ` ${c} `).join("│")}│`);
         if (i === 0) out.push(mid);
       });
       out.push(end);
@@ -102,7 +102,7 @@ export function renderMarkdown(md: string, opts: RenderOptions = {}): string {
   }
 
   for (let i = 0; i < lines.length; i++) {
-    let line = lines[i];
+    const line = lines[i];
 
     // Code block boundaries
     if (/^```/.test(line)) {
@@ -160,7 +160,7 @@ export function renderMarkdown(md: string, opts: RenderOptions = {}): string {
     if (bqMatch) {
       const inner = renderInline(bqMatch[1]);
       for (const wl of wrapLine(inner, width - 4)) {
-        out.push("│ " + wl);
+        out.push(`│ ${wl}`);
       }
       continue;
     }
@@ -170,7 +170,7 @@ export function renderMarkdown(md: string, opts: RenderOptions = {}): string {
     if (ulMatch) {
       const indent = ulMatch[1].length;
       const depth = Math.floor(indent / 2);
-      const prefix = "  ".repeat(depth) + "• ";
+      const prefix = `${"  ".repeat(depth)}• `;
       const inner = renderInline(ulMatch[2]);
       for (const wl of wrapLine(inner, width - prefix.length)) {
         out.push(prefix + wl);
@@ -183,7 +183,7 @@ export function renderMarkdown(md: string, opts: RenderOptions = {}): string {
     if (olMatch) {
       const indent = olMatch[1].length;
       const depth = Math.floor(indent / 2);
-      const prefix = "  ".repeat(depth) + "◦ ";
+      const prefix = `${"  ".repeat(depth)}◦ `;
       const inner = renderInline(olMatch[2]);
       for (const wl of wrapLine(inner, width - prefix.length)) {
         out.push(prefix + wl);