github-search-cli 9.6.0 → 9.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "github-search-cli",
-  "version": "9.6.0",
+  "version": "9.7.1",
   "description": "Search GitHub from your terminal — repo search, trending repos, npm package search, bookmarks, deep-dive, compare, export. Keyboard-driven TUI + pipeable CLI.",
   "type": "module",
   "packageManager": "bun@1",
@@ -37,13 +37,14 @@
     "format:check": "prettier --check .",
     "format": "prettier --write .",
     "typecheck": "tsc --noEmit",
-    "lint": "bunx biome@2.5.13 check .",
+    "lint": "biome check .",
     "check": "prettier --check . && bun test"
   },
   "dependencies": {
     "@opentui/core": "^0.4.3"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.5.14",
     "@types/bun": "latest",
     "@types/node": "^20.0.0",
     "prettier": "^3.2.0",

package/release-notes/9.7.0.md

@@ -0,0 +1,53 @@
+# What's New in ghfind 9.7.0
+
+CLI parity with the MCP tools — everything `ghfind mcp` exposes to coding
+agents is now a first-class terminal command — plus two fixes: `ghfind mcp`
+compiles again, and deep-dive shows real repo metadata.
+
+### Added
+
+**`ghfind deep-dive <owner/repo>`** — the MCP-only deep dive, on the CLI
+
+- Language breakdown with percentages, top contributors, and a README
+  excerpt (main → master → README.rst fallback)
+- Previously the agent skill doc literally told agents to `curl` GitHub
+  instead — not anymore
+- `--json` exposes a structured payload (language percents, contributor
+  counts, raw README) suitable for agents and scripting
+- Resolves real repo metadata first: `ghfind deep-dive vercel/next.js
+--json` reports actual stars, description, topics, and timestamps
+- A 404 exits with `Repo not found: owner/name` instead of silently
+  printing empty sections; network failures still degrade gracefully
+
+**`ghfind --compare` export formats** — `--json`, `--csv`, `--markdown`
+
+- Compare was text-only ("no JSON formatter for it yet"); all three
+  formatters now exist, with columns matching the other export modes
+- Repos that fail to resolve are reported in text output and excluded from
+  the table; fewer than 2 resolvable repos exits non-zero
+
+**Trending language filter on the CLI**
+
+- `ghfind trending rust` — the form the README already advertised but the
+  parser never handled — and `ghfind --trending rust` both work now
+- `ghfind --trending --language <lang>` names the flag explicitly
+- Unknown filters are rejected with the accepted list, the same validation
+  the `ghfind_trending` MCP tool applies
+
+### Changed
+
+- The MCP server now shares its repo-ref parsing, trending-language
+  validation, and deep-dive data pipeline with the CLI (new seams in
+  `deepdive.ts` and `search.ts`) — one source of truth, no protocol
+  behavior change
+
+### Fixed
+
+- **`ghfind mcp` failed to typecheck** — the id handed to
+  `respond`/`respondError` stayed `JsonRpcId | undefined` because
+  TypeScript's aliased-conditional narrowing does not apply through a `let`
+  binding; the id is now a `const`. Runtime behavior was already correct —
+  all 31 MCP tests pass unchanged.
+- **Deep-dive ran on a zeroed repo stub** — stars, forks, description, and
+  topics were all empty in both the CLI and the `ghfind_deep_dive` MCP
+  tool; real metadata is now fetched first (see above).

package/release-notes/9.7.1.md

@@ -0,0 +1,62 @@
+# What's New in ghfind 9.7.1
+
+The in-app update finally works — plus a Windows URL fix and a new doctor
+check that names every stale install shadowing your updates.
+
+### Fixed
+
+**In-app update installed to the wrong location**
+
+- When the TUI runs under Bun, `performUpdate()` ran `bun install -g
+github-search-cli`, which targets Bun's own global dir (`~/.bun`) — not
+  the npm prefix where the running copy and its `ghfind` shim live. The
+  command exited 0, "update succeeded", and the running install never
+  changed.
+- The updater now detects which package manager owns the running tree
+  (`detectInstallLocation`: npm global prefix vs `~/.bun` global) and
+  installs with `npm install -g --prefix <prefix>` for npm-owned installs,
+  so the update lands exactly where the running install is.
+- Compiled binaries and dev checkouts (no `node_modules` ancestor) refuse
+  self-update honestly instead of npm-installing a copy you aren't running.
+
+**Node fallback couldn't launch npm on Windows**
+
+- `child_process.spawn` without a shell cannot execute `npm.cmd` — recent
+  Node rejects it outright with `EINVAL`. The update spawn now goes through
+  `node:child_process` on every runtime with `shell: true` on win32, so the
+  Node fallback path works on Windows too.
+
+**Windows: URLs truncated at the first `&`**
+
+- Opening URLs via `cmd /c start "" <url>` split the URL at the first
+  unquoted `&` — a query-string separator — and tried to execute the rest
+  as a command. Every pre-filled crash-report/issue link lost its body and
+  labels.
+- Both URL openers now use `explorer.exe` on Windows, which receives the
+  URL as a single argument, so `&` is never interpreted.
+
+**New `ghfind --doctor` check: stale/PATH-shadowing installs**
+
+- Multiple `ghfind` copies on PATH resolving to different versions are the
+  classic "updater said OK but nothing changed" trap: the update lands in
+  one prefix while the shell keeps launching another. `ghfind --doctor` now
+  lists every install with its version and prints the exact
+  `npm uninstall -g github-search-cli --prefix <dir>` command to remove the
+  stale ones.
+
+### Changed
+
+- **CI enforces lint + typecheck** — the repo's first green Biome baseline
+  (198 diagnostics triaged, real `@biomejs/biome` 2.5.14 dependency replacing
+  the phantom `biome@2.5.13` pin) and a `.gitattributes` forcing LF so
+  `prettier --check` passes on Windows runners (main had been red on
+  windows-latest for weeks). Previously both gates were excluded as
+  known-broken; the typecheck-opentui-drift ticket is closed.
+
+### Internal
+
+- `open-url.ts` is runtime-agnostic with a detached Node fallback (it
+  previously crashed under Node via unconditional `Bun.spawn`).
+- Housekeeping: `mcp-server.ts` assignment-in-expressions, `trending-parser.ts`
+  stateful regex loop → `matchAll`, typed casts replacing `as any`, and a
+  repaired unsafe-autofix regression in `TrendingAdapter`.

package/scripts/build.ts

@@ -2,7 +2,7 @@
  * Build script — compile ghfind for distribution.
  * Usage: npm run build
  */
-import { execFileSync } from "child_process";
+import { execFileSync } from "node:child_process";
 
 async function main() {
   console.log("Building ghfind...");

package/scripts/postinstall.js

@@ -13,12 +13,12 @@ import {
   chmodSync,
   writeFileSync,
   readFileSync,
-} from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { platform, arch } from "os";
-import { spawnSync } from "child_process";
-import { inflateRawSync } from "zlib";
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { platform, arch } from "node:os";
+import { spawnSync } from "node:child_process";
+import { inflateRawSync } from "node:zlib";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = join(__dirname, "..");
@@ -121,8 +121,8 @@ try {
   let cdOffset = buffer.indexOf(cdSig, 0);
   while (cdOffset !== -1) {
     const nameLen = buffer.readUInt16LE(cdOffset + 28);
-    const extraLen = buffer.readUInt16LE(cdOffset + 30);
-    const commentLen = buffer.readUInt16LE(cdOffset + 32);
+    const _extraLen = buffer.readUInt16LE(cdOffset + 30);
+    const _commentLen = buffer.readUInt16LE(cdOffset + 32);
     const localHeaderOffset = buffer.readUInt32LE(cdOffset + 42);
     const compSize = buffer.readUInt32LE(cdOffset + 20);
     const compMethod = buffer.readUInt16LE(cdOffset + 10);

package/src/agent-skill.ts

@@ -54,7 +54,8 @@ Formats: --json | --csv | --markdown | --count | --format urls|names|ssh-urls|cl
 
 ## Trending repositories
 
-    ghfind --trending --json [--since daily|weekly|monthly]
+    ghfind --trending --json [--since daily|weekly|monthly] [--language rust]
+    ghfind trending rust --json      # subcommand form of the same thing
 
 ## npm packages
 
@@ -67,14 +68,14 @@ Formats: --json | --csv | --markdown | --count | --format urls|names|ssh-urls|cl
 
 ## Compare repositories
 
-    ghfind --compare owner/a owner/b [--json]
-Compare is text-only; there is no JSON formatter for it yet.
+    ghfind --compare owner/a owner/b [--json|--csv|--markdown]
+Errors if fewer than 2 of the requested repos resolve; unresolved names are
+reported in text output and via the error message.
 
 ## Deep-dive a repo (languages, contributors, README)
 
-Not exposed on the CLI. Fetch directly instead:
-  curl -s https://api.github.com/repos/OWNER/REPO/languages
-  curl -s https://raw.githubusercontent.com/OWNER/REPO/main/README.md
+    ghfind deep-dive owner/repo --json
+Text output (no flag) prints the same sections formatted for the terminal.
 
 ## Rate limits
 

package/src/cli.ts

@@ -22,11 +22,9 @@ import { runDoctor } from "./doctor";
 import { reportError } from "./error-report";
 import {
   format as formatOutput,
-  exportToFile,
   pipeExec,
   type Format,
   type ExportFormat,
-  type FormatLine,
 } from "./output";
 import { runWatch } from "./watch";
 import {
@@ -46,11 +44,24 @@ import {
 import { checkAndNotify, allCachedReleases } from "./releases";
 import { runInitWizard } from "./init";
 import { runLoginWizard } from "./login";
-import { buildComparisonTable } from "./compare";
+import {
+  buildComparisonTable,
+  comparisonJson,
+  comparisonCsv,
+  comparisonMarkdown,
+} from "./compare";
+import {
+  fetchDeepDiveRaw,
+  buildDeepDiveData,
+  buildDeepDiveJson,
+  buildDeepDiveText,
+  resolveRepoFromRef,
+} from "./deepdive";
+import { resolveTrendingLanguage } from "./search";
 import type { Repo } from "./types";
-import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import { launchBrowser } from "./tui";
 import { getVersion } from "./version";
 import { runMcpServer } from "./mcp-server";
@@ -96,6 +107,8 @@ interface CLIFlags {
   user?: string; // user profile lookup (ghfind user <name>)
   mcp: boolean; // run the MCP server (ghfind mcp)
   skill?: string; // agent skill guide (ghfind skill [name])
+  deepDive?: string; // repo deep-dive (ghfind deep-dive <owner/repo>)
+  language?: string; // trending language filter (--trending rust / ghfind trending rust)
 }
 
 function parseArgs(args: string[]): CLIFlags {
@@ -124,7 +137,7 @@ function parseArgs(args: string[]): CLIFlags {
     mcp: false,
   };
 
-  let queryParts: string[] = [];
+  const queryParts: string[] = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     switch (arg) {
@@ -142,6 +155,23 @@ function parseArgs(args: string[]): CLIFlags {
         break;
       case "--trending":
         flags.trending = true;
+        // `ghfind --trending rust` — first bare word is the language filter
+        break;
+      case "trending": {
+        // `ghfind trending rust` — subcommand form of --trending (README has
+        // claimed this works; now it does).
+        flags.trending = true;
+        if (
+          flags.query === "" &&
+          i + 1 < args.length &&
+          !args[i + 1].startsWith("-")
+        ) {
+          flags.language = args[++i];
+        }
+        break;
+      }
+      case "--language":
+        flags.language = args[++i];
         break;
       case "--watch":
         flags.watch = true;
@@ -168,8 +198,8 @@ function parseArgs(args: string[]): CLIFlags {
         flags.login = true;
         break;
       case "--limit": {
-        const parsed = parseInt(args[++i]);
-        if (isNaN(parsed) || parsed < 1 || parsed > 100) {
+        const parsed = parseInt(args[++i], 10);
+        if (Number.isNaN(parsed) || parsed < 1 || parsed > 100) {
           console.error(`Invalid limit: must be 1-100. Using default 50.`);
           flags.limit = 50;
         } else {
@@ -204,6 +234,15 @@ function parseArgs(args: string[]): CLIFlags {
       case "mcp":
         flags.mcp = true;
         break;
+      case "deep-dive": {
+        // Single repo ref (owner/name); a following flag means none.
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags.deepDive = next;
+          i++;
+        }
+        break;
+      }
       case "skill": {
         // Optional skill id (ids contain no spaces); a following flag means none.
         const next = args[i + 1];
@@ -284,8 +323,12 @@ Usage:
   ghfind <query> --format <fmt>    Format lines (urls|names|ssh-urls|clone-commands|ids)
   ghfind <query> --pipe <target>   Pipe to clone/open
   ghfind --trending --json         Trending repos as JSON
+  ghfind trending <lang>           Trending repos, optionally by language
   ghfind --releases                Check bookmarks for new releases
   ghfind --compare <r1> <r2>       Compare two+ repos side-by-side
+  ghfind --compare a/b c/d --json  Compare as JSON|CSV|Markdown
+  ghfind deep-dive <owner/repo>    Deep-dive: languages, contributors, README
+  ghfind deep-dive a/b --json      Deep-dive as JSON
   ghfind org <name> --json         Org profile: repos, stars, top languages
   ghfind user <name> --json        User profile: repos, stars, top languages
   ghfind pkg <query> --json        Search npm packages, output JSON
@@ -306,6 +349,7 @@ Options:
   --sort <strategy>                    Sort: best-match|stars|updated|forks
   --theme <name>                     Theme: tokyo-night|premium-dark (default: tokyo-night)
   --trending                           Trending mode
+  --language <lang>                    Trending language filter (e.g. rust)
   --since <period>                     Trending period: daily|weekly|monthly
   --pipe <target>                      Pipe target: clone|open
   --format <fmt>                       Line format: urls|names|ssh-urls|...
@@ -384,6 +428,12 @@ Options:
         ? "markdown"
         : undefined;
 
+  // Repo deep-dive — parity with the MCP ghfind_deep_dive tool
+  if (flags.deepDive !== undefined) {
+    await runDeepDive(flags, outputFormat);
+    return;
+  }
+
   // Org profile mode — independent of repo search handlers
   // (checks presence, not truthiness, so `ghfind org` with no name errors helpfully)
   if (flags.org !== undefined) {
@@ -403,7 +453,10 @@ Options:
     flags.format ||
     flags.pipe ||
     flags.watch ||
-    flags.releases;
+    flags.releases ||
+    // `ghfind trending rust` / `ghfind --trending rust` print a list —
+    // a language filter implies non-interactive output
+    (flags.trending && (!!flags.language || !!flags.query));
 
   // Non-interactive mode
   if (isNonInteractive) {
@@ -458,7 +511,12 @@ async function runUserProfile(
   outputFormat?: ExportFormat,
 ): Promise<void> {
   try {
-    const profile = await fetchUserProfile(flags.user!, {
+    const user = flags.user ?? "";
+    if (!user) {
+      console.error("Usage: ghfind user <name> [--json] [--token <t>]");
+      process.exit(1);
+    }
+    const profile = await fetchUserProfile(user, {
       token: flags.token,
       limit: flags.limit,
     });
@@ -485,7 +543,12 @@ async function runOrgProfile(
   outputFormat?: ExportFormat,
 ): Promise<void> {
   try {
-    const profile = await fetchOrgProfile(flags.org!, {
+    const org = flags.org ?? "";
+    if (!org) {
+      console.error("Usage: ghfind org <name> [--json] [--token <t>]");
+      process.exit(1);
+    }
+    const profile = await fetchOrgProfile(org, {
       token: flags.token,
       limit: flags.limit,
     });
@@ -506,6 +569,32 @@ async function runOrgProfile(
   }
 }
 
+/** `ghfind deep-dive <owner/repo>` — rich repo detail: languages, contributors, README. */
+async function runDeepDive(
+  flags: CLIFlags,
+  outputFormat?: ExportFormat,
+): Promise<void> {
+  const ref = flags.deepDive;
+  if (!ref) {
+    console.error(
+      "Usage: ghfind deep-dive <owner/repo> [--json] [--token <t>]",
+    );
+    process.exit(1);
+  }
+  try {
+    const repo = await resolveRepoFromRef(ref, flags.token); // validates + real metadata
+    const raw = await fetchDeepDiveRaw(repo, flags.token);
+    if (outputFormat === "json") {
+      console.log(buildDeepDiveJson(raw));
+    } else {
+      console.log(buildDeepDiveText(buildDeepDiveData(repo, raw)));
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
 /** `ghfind pkg "<query>"` — npm package search. Pass-through query to the registry. */
 async function runPackageSearch(flags: CLIFlags): Promise<void> {
   if (flags.registry !== "npm") {
@@ -603,7 +692,7 @@ async function runReleases(
 async function runNonInteractive(flags: CLIFlags, outputFormat?: ExportFormat) {
   // Dispatch table: each handler receives shared context + flags, returns void.
   const handlers: Record<string, (ctx: SearchContext) => Promise<void>> = {
-    trending: async (ctx) => {
+    trending: async (_ctx) => {
       const since =
         flags.since === "weekly"
           ? "weekly"
@@ -611,6 +700,20 @@ async function runNonInteractive(flags: CLIFlags, outputFormat?: ExportFormat) {
             ? "monthly"
             : "daily";
       const trendingSearch = createTrendingSearch();
+      // Language filter: validated against github.com/trending's accepted
+      // set (same validation as the MCP ghfind_trending tool).
+      let language: string | undefined;
+      try {
+        // `ghfind trending rust` puts the language in flags.language;
+        // `ghfind --trending rust` leaves it as the query's first word.
+        language = resolveTrendingLanguage(
+          flags.language ??
+            (flags.query ? flags.query.split(/\s+/)[0] : undefined),
+        );
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
       const response = await trendingSearch.search(
         { keywords: [], qualifiers: [], raw: "trending" },
         {
@@ -619,6 +722,7 @@ async function runNonInteractive(flags: CLIFlags, outputFormat?: ExportFormat) {
           json: false,
           verbose: false,
           trendingSince: since,
+          ...(language ? { trendingLanguage: language } : {}),
         },
       );
       if (outputFormat) {
@@ -677,7 +781,7 @@ async function runNonInteractive(flags: CLIFlags, outputFormat?: ExportFormat) {
         token: flags.token,
       });
       const repos = rankRepos(response.repos, flags.sort);
-      await pipeExec(repos, flags.pipe!);
+      if (flags.pipe) await pipeExec(repos, flags.pipe);
     },
     format: async (ctx) => {
       const response = await ctx.provider.search(ctx.parsed, {
@@ -710,6 +814,7 @@ async function runNonInteractive(flags: CLIFlags, outputFormat?: ExportFormat) {
     compare: async (_ctx) => {
       const search = createGitHubSearch(undefined, [flags.token ?? ""]);
       const repos: Repo[] = [];
+      const missing: string[] = [];
       for (const fullName of flags.compare) {
         const res = await search.search(
           { keywords: [fullName], qualifiers: [], raw: fullName },
@@ -721,9 +826,27 @@ async function runNonInteractive(flags: CLIFlags, outputFormat?: ExportFormat) {
             token: flags.token,
           },
         );
-        repos.push(...res.repos);
+        if (res.repos.length > 0) repos.push(...res.repos);
+        else missing.push(fullName);
+      }
+      if (repos.length < 2) {
+        console.error(
+          `Could not resolve enough repos to compare (found ${repos.length}${missing.length ? `; not found: ${missing.join(", ")}` : ""}).`,
+        );
+        process.exit(1);
+      }
+      const notFound = missing.length
+        ? `\n\nNot found: ${missing.join(", ")}`
+        : "";
+      if (outputFormat === "json") {
+        console.log(comparisonJson(repos));
+      } else if (outputFormat === "csv") {
+        console.log(comparisonCsv(repos));
+      } else if (outputFormat === "markdown") {
+        console.log(comparisonMarkdown(repos));
+      } else {
+        console.log(buildComparisonTable(repos) + notFound);
       }
-      console.log(buildComparisonTable(repos));
     },
   };
 

package/src/compare.ts

@@ -1,5 +1,6 @@
 /**
- * Repo comparison — side-by-side table for 2+ repos.
+ * Repo comparison — side-by-side table for 2+ repos, plus JSON/CSV/Markdown
+ * exports (shared by the CLI `--compare` formatters and the MCP server).
  */
 import type { Repo } from "./types";
 
@@ -51,9 +52,9 @@ export function buildComparisonTable(repos: Repo[]): string {
   const sep = ["".padEnd(14, "─"), ...names.map(() => "".padEnd(colW, "─"))];
 
   const lines: string[] = [
-    "┌" + sep.map((s) => "─" + s + "─").join("┬") + "┐",
-    "│" + header.map((h) => ` ${h} `).join("│") + "│",
-    "├" + sep.map((s) => "─" + s + "─").join("┼") + "┤",
+    `┌${sep.map((s) => `─${s}─`).join("┬")}┐`,
+    `│${header.map((h) => ` ${h} `).join("│")}│`,
+    `├${sep.map((s) => `─${s}─`).join("┼")}┤`,
   ];
 
   for (const row of rows) {
@@ -61,9 +62,83 @@ export function buildComparisonTable(repos: Repo[]): string {
       row.label.padEnd(14),
       ...row.values.map((v) => v.padEnd(colW)),
     ];
-    lines.push("│" + cells.map((c) => ` ${c} `).join("│") + "│");
+    lines.push(`│${cells.map((c) => ` ${c} `).join("│")}│`);
   }
 
-  lines.push("└" + sep.map((s) => "─" + s + "─").join("┴") + "┘");
+  lines.push(`└${sep.map((s) => `─${s}─`).join("┴")}┘`);
   return lines.join("\n");
 }
+
+// ─── Export formatters (parity with org/user/package modules) ──────────
+
+/** The repo fields the comparison surface exposes. */
+export interface ComparisonRepo {
+  fullName: string;
+  url: string;
+  description: string | null;
+  stars: number;
+  forks: number;
+  language: string | null;
+  createdAt: string;
+  updatedAt: string;
+  topics: string[];
+  archived: boolean;
+}
+
+function comparisonRepo(r: Repo): ComparisonRepo {
+  return {
+    fullName: r.fullName,
+    url: r.url,
+    description: r.description,
+    stars: r.stars,
+    forks: r.forks,
+    language: r.language,
+    createdAt: r.createdAt,
+    updatedAt: r.updatedAt,
+    topics: r.topics,
+    archived: r.archived,
+  };
+}
+
+export function comparisonJson(repos: Repo[]): string {
+  return JSON.stringify(repos.map(comparisonRepo), null, 2);
+}
+
+function csvEscape(val: unknown): string {
+  const str = String(val ?? "");
+  if (str.includes('"') || str.includes(",") || str.includes("\n")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+
+export function comparisonCsv(repos: Repo[]): string {
+  const header = "full_name,stars,forks,language,created,updated,archived,url";
+  const rows = repos.map((r) =>
+    [
+      r.fullName,
+      r.stars,
+      r.forks,
+      r.language ?? "",
+      r.createdAt?.slice(0, 10) ?? "",
+      r.updatedAt?.slice(0, 10) ?? "",
+      String(r.archived),
+      r.url,
+    ]
+      .map(csvEscape)
+      .join(","),
+  );
+  return [header, ...rows].join("\n");
+}
+
+export function comparisonMarkdown(repos: Repo[]): string {
+  const header =
+    "| Repo | Stars | Forks | Language | Created | Updated | Topics |";
+  const sep =
+    "|------|-------|-------|----------|---------|---------|--------|";
+  const rows = repos.map(
+    (r) =>
+      `| [${r.fullName}](${r.url}) | ${r.stars.toLocaleString()} | ${r.forks.toLocaleString()} | ${r.language ?? "—"} | ${r.createdAt?.slice(0, 7) ?? "—"} | ${r.updatedAt?.slice(0, 10) ?? "—"} | ${(r.topics?.slice(0, 5).join(", ") ?? "") || "—"} |`,
+  );
+  return [header, sep, ...rows].join("\n");
+}

package/src/config.ts

@@ -7,9 +7,9 @@
  *   3. ~/.config/ghfind/config.json
  */
 import type { Config } from "./types";
-import { homedir } from "os";
-import { join } from "path";
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 
 /** Directory for persistent state (history, bookmarks, session). */
 export function stateDir(): string {