github-search-cli 9.8.0 → 9.8.1

package/src/markdown-view.ts

@@ -35,6 +35,10 @@ import {
 /** Tallest inline image, in terminal cells. */
 export const MAX_IMAGE_ROWS = 24;
 
+/** Cap on memoised rasters — a resize session re-keys on width, so this
+ *  would otherwise grow without bound. */
+const RASTER_CACHE_LIMIT = 32;
+
 export interface MarkdownViewOptions {
   renderer: CliRenderer;
   /** Theme palette (see src/themes.ts). */
@@ -182,6 +186,13 @@ export function createMarkdownView(opts: MarkdownViewOptions): MarkdownView {
       });
     })();
     rasterCache.set(key, pending);
+    // Map iteration order is insertion order, so the first key is the oldest.
+    // Unbounded growth would re-rasterize every image on every resize.
+    while (rasterCache.size > RASTER_CACHE_LIMIT) {
+      const oldest = rasterCache.keys().next().value;
+      if (oldest === undefined) break;
+      rasterCache.delete(oldest);
+    }
     return pending;
   };
 
@@ -200,9 +211,6 @@ export function createMarkdownView(opts: MarkdownViewOptions): MarkdownView {
 
     void rasterize(url).then(
       (cells) => {
-        console.error(
-          `[dbg] image resolved: cells=${cells ? `${cells.cols}x${cells.rows}` : "null"} destroyed=${container.isDestroyed} parent=${!!container.parent} enabled=${imagesEnabled}`,
-        );
         // The document may have been replaced (or the overlay closed) while
         // the image was downloading.
         if (container.isDestroyed || !container.parent) return;
@@ -223,7 +231,8 @@ export function createMarkdownView(opts: MarkdownViewOptions): MarkdownView {
         renderable.requestRender();
       },
       (err) => {
-        console.error("[dbg] image promise rejected:", err);
+        // Swallow: a failed image should not crash the view.
+        void err;
       },
     );
     return container;
@@ -288,6 +297,13 @@ export function createMarkdownView(opts: MarkdownViewOptions): MarkdownView {
       renderable.fg = text();
       renderable.bg = bg();
       renderable.content = markdown;
+      // Finalize streaming so the last tokens are no longer marked unstable.
+      // Without this, OpenTUI keeps the trailing 2 blocks perpetually
+      // unstable in streaming mode, which recreates image render nodes (and
+      // their pending fetch promises) on every render cycle — the promise
+      // resolves after the loop idles and never settles.
+      renderable.streaming = false;
+      renderable.requestRender();
     },
     setImagesEnabled(enabled: boolean) {
       if (imagesEnabled === enabled) return;

package/src/mcp-server.ts

@@ -17,6 +17,7 @@
  *   ghfind_deep_dive            deepdive.ts
  *   ghfind_bookmarked_releases  releases.ts + bookmarks.ts (read-only)
  *   ghfind_skill                agent-skill.ts
+ *   ghfind_skill_search         skill-finder.ts (local scan | skills.sh HTTP)
  *
  * Only the tools capability is declared (no prompts/resources yet), so those
  * methods fall through to "Method not found".
@@ -47,6 +48,12 @@ import { getBookmarks } from "./bookmarks";
 import { appendHistory } from "./history";
 import { loadConfig } from "./config";
 import { ensureBuiltinSkill, getSkill } from "./agent-skill";
+import {
+  formatSkillSearchText,
+  searchSkills,
+  type SkillSearchResult,
+  type SkillSource,
+} from "./skill-finder";
 import { getVersion } from "./version";
 
 // ─── Protocol constants ────────────────────────────────────────────────
@@ -212,6 +219,8 @@ const TRENDING_QUERY = { keywords: [], qualifiers: [], raw: "trending" };
 // ─── Tool registry ─────────────────────────────────────────────────────
 
 const REPO_SORTS = ["best-match", "stars", "updated", "forks"] as const;
+/** Skill search sources: this machine, or the public skills.sh ecosystem. */
+const SKILL_SOURCES = ["local", "registry"] as const;
 const TRENDING_SINCE = ["daily", "weekly", "monthly"] as const;
 const PKG_SORTS = ["best-match", "score", "downloads", "name"] as const;
 
@@ -599,6 +608,56 @@ const TOOLS: ToolDefinition[] = [
       };
     },
   },
+  {
+    name: "ghfind_skill_search",
+    title: "Search agent skills",
+    description:
+      "Search installed agent skills (SKILL.md files under the user's skill directories) or the public skills.sh ecosystem by keyword, and return matching skills with their descriptions. Read-only: it never installs anything - registry hits include the `npx skills add` command for the user to run deliberately. Use when the user asks to find a skill for a task, or asks what skills are available.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description:
+            'Keyword to match against skill names and descriptions, e.g. "changelog" or "testing" (2+ characters).',
+        },
+        source: {
+          type: "string",
+          description:
+            "Where to search: 'local' for skills installed on this machine (default), 'registry' for the public skills.sh ecosystem.",
+          enum: [...SKILL_SOURCES],
+        },
+        limit: {
+          type: "number",
+          description: "Max results, 1-100 (default 20).",
+          minimum: 1,
+          maximum: 100,
+        },
+      },
+      required: ["query"],
+    },
+    async run(args) {
+      const source = coerceEnum<SkillSource>(
+        args.source,
+        SKILL_SOURCES,
+        "local",
+      );
+      const limit = coerceInt(args.limit, 20, 1, 100);
+      const result: SkillSearchResult = await searchSkills(
+        String(args.query ?? ""),
+        { source, limit },
+      );
+      const where =
+        result.source === "local"
+          ? "installed skills on this machine"
+          : "the public skills.sh ecosystem";
+      const header = `${result.count} match(es) for "${result.query}" in ${where}:`;
+      return {
+        text: `${header}\n\n${formatSkillSearchText(result)}`,
+        data: { ...result },
+      };
+    },
+  },
 ];
 
 /** Tools/list payload (name, title, description, inputSchema only). */
@@ -737,6 +796,7 @@ export async function processServerLine(
           },
           instructions:
             "ghfind gives agents GitHub search: repositories, trending, npm packages, org/user profiles, repo comparison and deep-dives. " +
+            "ghfind_skill_search finds agent skills, either installed on this machine or in the public skills.sh ecosystem. " +
             "Call ghfind_skill for the full CLI guide. Unauthenticated requests are rate-limited to 60/hr; pass a token or set GITHUB_TOKEN for 5,000/hr.",
         }),
       );

package/src/readme.ts

@@ -0,0 +1,54 @@
+/**
+ * README retrieval.
+ *
+ * A repository's README can live at one of three URLs, and the first guess
+ * ("main") 404s often enough that awaiting the candidates one at a time
+ * triples the time before any text appears. All three are therefore fired at
+ * once and the first *usable* response wins.
+ */
+import { readmeBaseUrl } from "./image-loader";
+
+export interface Readme {
+  /** The raw README markdown (or reStructuredText). */
+  text: string;
+  /**
+   * Where the README came from. Its own URL doubles as the base for resolving
+   * relative image paths, so it must match the branch that actually served.
+   */
+  sourceUrl: string;
+}
+
+/**
+ * Candidate README locations, most likely first.
+ */
+const CANDIDATES: ReadonlyArray<readonly [string, string]> = [
+  ["main", "README.md"],
+  ["master", "README.md"],
+  ["main", "README.rst"],
+];
+
+export async function fetchReadme(
+  owner: string,
+  repo: string,
+  opts: { token?: string; fetchImpl?: typeof fetch } = {},
+): Promise<Readme | null> {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const headers: Record<string, string> = { "User-Agent": "ghfind/1.0" };
+  if (opts.token) headers.Authorization = `Bearer ${opts.token}`;
+
+  const attempts = CANDIDATES.map(async ([branch, file]) => {
+    const url = readmeBaseUrl(owner, repo, branch, file);
+    const res = await fetchImpl(url, { headers });
+    // Reject rather than resolve with null: Promise.any settles on the first
+    // *fulfilled* promise, so a 404 that resolved would beat the real README.
+    if (!res.ok) throw new Error(`no readme at ${url}`);
+    return { text: await res.text(), sourceUrl: url } satisfies Readme;
+  });
+
+  try {
+    return await Promise.any(attempts);
+  } catch {
+    // AggregateError: every candidate failed.
+    return null;
+  }
+}

package/src/skill-finder.ts

@@ -0,0 +1,445 @@
+/**
+ * skill-finder.ts — keyword search over agent skills, from two sources.
+ *
+ * Agents start a session not knowing which skills this machine has, and the
+ * public skills ecosystem is searched through a web page. This module gives
+ * both a single seam:
+ *
+ *   source      where results come from                          transport
+ *   ─────────── ──────────────────────────────────────────────── ─────────────
+ *   local       SKILL.md files installed under the four roots    filesystem
+ *   registry    skills.sh public ecosystem                      HTTPS (public)
+ *
+ * Everything here is read-only: nothing is downloaded, installed, or written.
+ * Registry results carry the `npx skills add` command for a human or agent to
+ * run deliberately.
+ */
+import { readdirSync, readFileSync } from "node:fs";
+import type { Dirent } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+/** Where an installed skill was found, and what it says about itself. */
+export interface LocalSkillHit {
+  /** The skill's frontmatter `name`. Also the `ghfind skill <name>` selector. */
+  name: string;
+  /** One-line summary from frontmatter (newlines collapsed). */
+  description: string;
+  /** Absolute path to the SKILL.md that won de-duplication. */
+  path: string;
+  /** Human-readable root the skill came from (home abbreviated to `~`). */
+  origin: string;
+}
+
+/** One skill from the public skills.sh ecosystem. */
+export interface RegistrySkillHit {
+  /** `owner/repo/skillId` — the unique ecosystem id. */
+  id: string;
+  /** Source repository, `owner/repo`. */
+  source: string;
+  /** Skill id within that repository. */
+  skillId: string;
+  /** Display name (the ecosystem sometimes supplies a title-case name). */
+  name: string;
+  /** Install count, the ecosystem's popularity signal. */
+  installs: number;
+  /** Command a human or agent can run to install it. */
+  installCommand: string;
+  /** Page for the skill on skills.sh. */
+  url: string;
+}
+
+export interface LocalSkillSearchResult {
+  query: string;
+  source: "local";
+  count: number;
+  skills: LocalSkillHit[];
+}
+
+export interface RegistrySkillSearchResult {
+  query: string;
+  source: "registry";
+  count: number;
+  skills: RegistrySkillHit[];
+}
+
+/** A skill search outcome, discriminated by `source`. */
+export type SkillSearchResult =
+  LocalSkillSearchResult | RegistrySkillSearchResult;
+
+export type SkillSource = "local" | "registry";
+
+/** The skills.sh search endpoint (public, no auth). */
+export const REGISTRY_SEARCH_ENDPOINT = "https://skills.sh/api/search";
+
+/** Shortest accepted query. skills.sh rejects anything shorter with HTTP 400. */
+export const MIN_QUERY_LENGTH = 2;
+
+/** Result cap, applied to both sources. */
+export const MAX_SKILL_RESULTS = 100;
+
+// ─── Local roots ──────────────────────────────────────────────────────────
+
+/** One scan root: where it is, and the label results carry. */
+interface SkillRoot {
+  path: string;
+  label: string;
+}
+
+/** Abbreviate a path for display: home becomes `~`, separators become `/`. */
+function displayPath(path: string): string {
+  const home = homedir();
+  const normalized = path.replace(/\\/g, "/");
+  const homeNorm = home.replace(/\\/g, "/").replace(/\/$/, "");
+  if (normalized === homeNorm) return "~";
+  if (normalized.startsWith(`${homeNorm}/`)) {
+    return `~${normalized.slice(homeNorm.length)}`;
+  }
+  return normalized;
+}
+
+/**
+ * The four roots scanned for installed skills, highest priority first.
+ *
+ * User-level roots outrank project-level ones, and `~/.codex/skills` outranks
+ * `~/.agents/skills`: the two overlap heavily on real machines, and the
+ * Codex-managed copy is the one its own tooling reads.
+ */
+export function defaultSkillRoots(cwd: string = process.cwd()): string[] {
+  const home = homedir();
+  return [
+    join(home, ".codex", "skills"),
+    join(home, ".agents", "skills"),
+    join(cwd, ".codex", "skills"),
+    join(cwd, ".github", "skills"),
+  ];
+}
+
+/**
+ * Scan roots in priority order. `GHFIND_SKILL_ROOTS` overrides the defaults —
+ * the seam tests and the MCP tool use it to point at a fixture directory
+ * instead of the real machine. It is split on the platform delimiter only
+ * (`;` on Windows, `:` elsewhere), so a Windows drive letter survives.
+ */
+export function resolveSkillRoots(cwd: string = process.cwd()): SkillRoot[] {
+  const override = process.env.GHFIND_SKILL_ROOTS;
+  const paths = override?.trim()
+    ? override
+        .split(delimiter)
+        .filter((p) => p.trim())
+        .map((p) => p.trim())
+    : defaultSkillRoots(cwd);
+  return paths.map((path) => ({ path, label: displayPath(path) }));
+}
+
+// ─── Frontmatter ──────────────────────────────────────────────────────────
+
+/** Directories never worth walking into. Hidden dirs ARE walked (`.system`). */
+const SKIP_DIRS = new Set(["node_modules", ".git"]);
+
+/** Cap on directory depth, so a symlink loop cannot hang a scan. */
+const MAX_DEPTH = 4;
+
+/** Strip one layer of matching quotes from a frontmatter scalar. */
+function unquote(value: string): string {
+  const trimmed = value.trim();
+  if (
+    trimmed.length >= 2 &&
+    ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+      (trimmed.startsWith("'") && trimmed.endsWith("'")))
+  ) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+
+/**
+ * Read `name` and `description` out of a SKILL.md frontmatter block.
+ *
+ * Handles the three shapes real skills use: plain scalars, quoted scalars
+ * (`name: "imagegen"`), and folded/literal blocks (`description: >` followed
+ * by indented lines). Returns null when there is no frontmatter block.
+ */
+export function parseSkillFrontmatter(
+  text: string,
+): { name: string; description: string } | null {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+  if (!match) return null;
+  const lines = match[1].split(/\r?\n/);
+  const fields: Record<string, string> = {};
+  for (let i = 0; i < lines.length; i++) {
+    const field = /^([A-Za-z_][\w-]*):[ \t]*(.*)$/.exec(lines[i]);
+    if (!field) continue;
+    const key = field[1].toLowerCase();
+    const inline = field[2].trim();
+    if (inline === ">" || inline === "|" || /^[>|][-+]?$/.test(inline)) {
+      // Block scalar: gather the following more-indented lines.
+      const literal = inline.startsWith("|");
+      const parts: string[] = [];
+      while (i + 1 < lines.length && /^[ \t]+\S/.test(lines[i + 1])) {
+        parts.push(lines[++i].trim());
+      }
+      fields[key] = literal ? parts.join("\n") : parts.join(" ");
+    } else {
+      fields[key] = unquote(inline);
+    }
+  }
+  const name = fields.name ?? "";
+  if (!name) return null;
+  return { name, description: fields.description ?? "" };
+}
+
+// ─── Local scan ───────────────────────────────────────────────────────────
+
+/**
+ * Walk the roots and collect every readable SKILL.md, de-duplicated by name.
+ *
+ * The first root to claim a name wins; within a root the shallowest path wins
+ * (breadth-first order). Unreadable directories and malformed files are skipped
+ * rather than failing the whole scan — a scan is best-effort by nature.
+ */
+export function scanLocalSkills(
+  roots: SkillRoot[] = resolveSkillRoots(),
+): LocalSkillHit[] {
+  const byName = new Map<string, LocalSkillHit>();
+  for (const root of roots) {
+    for (const dir of walkDirs(root.path)) {
+      const entries = listDir(dir);
+      if (!entries) continue;
+      if (!entries.some((e) => e.isFile() && e.name === "SKILL.md")) continue;
+      const file = join(dir, "SKILL.md");
+      try {
+        const parsed = parseSkillFrontmatter(readFileSync(file, "utf-8"));
+        if (!parsed || byName.has(parsed.name)) continue;
+        byName.set(parsed.name, {
+          name: parsed.name,
+          description: parsed.description.replace(/\s+/g, " ").trim(),
+          path: file,
+          origin: root.label,
+        });
+      } catch {
+        // unreadable file — skip it, the rest of the scan still stands
+      }
+    }
+  }
+  return [...byName.values()];
+}
+
+/** Directory entries, or null when the directory is missing or unreadable. */
+function listDir(dir: string): Dirent[] | null {
+  try {
+    return readdirSync(dir, { withFileTypes: true }) as Dirent[];
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Directories under `root`, breadth-first and depth-capped so a symlink loop
+ * cannot hang a scan. `node_modules` and `.git` are pruned; other hidden
+ * directories (e.g. `.system`) are walked.
+ */
+function* walkDirs(root: string): Generator<string> {
+  const queue: Array<[string, number]> = [[root, 0]];
+  while (queue.length > 0) {
+    const [dir, depth] = queue.shift() as [string, number];
+    const entries = listDir(dir);
+    if (!entries) continue;
+    yield dir;
+    if (depth >= MAX_DEPTH) continue;
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
+      queue.push([join(dir, entry.name), depth + 1]);
+    }
+  }
+}
+
+// ─── Ranking ──────────────────────────────────────────────────────────────
+
+/** Match tiers, best first: exact name, name prefix, name, description. */
+function localMatchTier(hit: LocalSkillHit, needle: string): number | null {
+  const name = hit.name.toLowerCase();
+  if (name === needle) return 0;
+  if (name.startsWith(needle)) return 1;
+  if (name.includes(needle)) return 2;
+  if (hit.description.toLowerCase().includes(needle)) return 3;
+  return null;
+}
+
+/** Filter + rank local skills for a query. */
+export function rankLocalSkills(
+  hits: LocalSkillHit[],
+  query: string,
+  limit: number = MAX_SKILL_RESULTS,
+): LocalSkillHit[] {
+  const needle = query.trim().toLowerCase();
+  return hits
+    .map((hit) => ({ hit, tier: localMatchTier(hit, needle) }))
+    .filter(
+      (entry): entry is { hit: LocalSkillHit; tier: number } =>
+        entry.tier !== null,
+    )
+    .sort((a, b) => a.tier - b.tier || a.hit.name.localeCompare(b.hit.name))
+    .slice(0, clampLimit(limit))
+    .map((entry) => entry.hit);
+}
+
+/** Clamp a result limit into 1..MAX_SKILL_RESULTS. */
+export function clampLimit(limit: number): number {
+  const n = Math.trunc(Number(limit));
+  if (!Number.isFinite(n)) return MAX_SKILL_RESULTS;
+  return Math.min(Math.max(n, 1), MAX_SKILL_RESULTS);
+}
+
+/** Throw for queries both sources reject, before any work is done. */
+export function assertSearchableQuery(query: string): string {
+  const trimmed = query.trim();
+  if (trimmed.length < MIN_QUERY_LENGTH) {
+    throw new Error(
+      `Query must be at least ${MIN_QUERY_LENGTH} characters (got "${trimmed}").`,
+    );
+  }
+  return trimmed;
+}
+
+// ─── Search entry points ──────────────────────────────────────────────────
+
+/** Search skills installed on this machine. */
+export function searchLocalSkills(
+  query: string,
+  opts: { limit?: number; roots?: SkillRoot[] } = {},
+): LocalSkillSearchResult {
+  const trimmed = assertSearchableQuery(query);
+  const skills = rankLocalSkills(
+    scanLocalSkills(opts.roots ?? resolveSkillRoots()),
+    trimmed,
+    opts.limit ?? MAX_SKILL_RESULTS,
+  );
+  return { query: trimmed, source: "local", count: skills.length, skills };
+}
+
+/** Normalize one skills.sh search result. */
+function normalizeRegistrySkill(raw: unknown): RegistrySkillHit | null {
+  if (typeof raw !== "object" || raw === null) return null;
+  const obj = raw as Record<string, unknown>;
+  const source = typeof obj.source === "string" ? obj.source : "";
+  const skillId = typeof obj.skillId === "string" ? obj.skillId : "";
+  if (!source || !skillId) return null;
+  const name =
+    typeof obj.name === "string" && obj.name.trim() ? obj.name : skillId;
+  const installs = typeof obj.installs === "number" ? obj.installs : 0;
+  const id =
+    typeof obj.id === "string" && obj.id ? obj.id : `${source}/${skillId}`;
+  return {
+    id,
+    source,
+    skillId,
+    name,
+    installs,
+    installCommand: `npx skills add ${source}@${skillId}`,
+    url: `https://skills.sh/${source}/${skillId}`,
+  };
+}
+
+/**
+ * Search the public skills.sh ecosystem.
+ *
+ * Read-only: results carry the command to install, never an install. Network
+ * and protocol failures surface as plain Errors with a user-facing message.
+ */
+export async function searchRegistrySkills(
+  query: string,
+  opts: { limit?: number; fetchImpl?: typeof fetch } = {},
+): Promise<RegistrySkillSearchResult> {
+  const trimmed = assertSearchableQuery(query);
+  const limit = clampLimit(opts.limit ?? MAX_SKILL_RESULTS);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const url = `${REGISTRY_SEARCH_ENDPOINT}?q=${encodeURIComponent(trimmed)}&limit=${limit}`;
+
+  let res: Response;
+  try {
+    res = await fetchImpl(url, {
+      headers: { Accept: "application/json", "User-Agent": "ghfind/1.0" },
+    });
+  } catch (err) {
+    throw new Error(
+      `Could not reach skills.sh: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+  if (!res.ok) {
+    throw new Error(
+      `skills.sh returned HTTP ${res.status} for "${trimmed}". Retry, or search locally with --local.`,
+    );
+  }
+
+  let payload: unknown;
+  try {
+    payload = await res.json();
+  } catch {
+    throw new Error("skills.sh returned a response that was not JSON.");
+  }
+  const items = (payload as { skills?: unknown[] })?.skills ?? [];
+  const skills = items
+    .map(normalizeRegistrySkill)
+    .filter((s): s is RegistrySkillHit => s !== null)
+    .slice(0, limit);
+  return { query: trimmed, source: "registry", count: skills.length, skills };
+}
+
+/** Search skills by source — the single entry point CLI and MCP share. */
+export async function searchSkills(
+  query: string,
+  opts: {
+    source?: SkillSource;
+    limit?: number;
+    roots?: SkillRoot[];
+    fetchImpl?: typeof fetch;
+  } = {},
+): Promise<SkillSearchResult> {
+  if ((opts.source ?? "local") === "registry") {
+    return searchRegistrySkills(query, opts);
+  }
+  return searchLocalSkills(query, opts);
+}
+
+// ─── Formatting ───────────────────────────────────────────────────────────
+
+/** JSON payload for either source (the shape agents should parse). */
+export function formatSkillSearchJson(result: SkillSearchResult): string {
+  return JSON.stringify(result, null, 2);
+}
+
+/** Trim a description to one readable line for text output. */
+function shortDescription(description: string, width = 100): string {
+  if (description.length <= width) return description;
+  return `${description.slice(0, width - 1).trimEnd()}…`;
+}
+
+/** Human/agent-readable text for a search result. */
+export function formatSkillSearchText(result: SkillSearchResult): string {
+  if (result.count === 0) {
+    return result.source === "local"
+      ? `No installed skills match "${result.query}". Try --remote to search the skills.sh ecosystem.`
+      : `No skills.sh entries match "${result.query}".`;
+  }
+  if (result.source === "local") {
+    return result.skills
+      .map(
+        (s) => `${s.name}  (${s.origin})\n  ${shortDescription(s.description)}`,
+      )
+      .join("\n");
+  }
+  return result.skills
+    .map(
+      (s) =>
+        `${s.name}  ${s.installs.toLocaleString()} installs  [${s.source}]\n  ${s.installCommand}`,
+    )
+    .join("\n");
+}
+
+/** Names only — the pipe-friendly form (`ghfind skill search x --names`). */
+export function formatSkillSearchNames(result: SkillSearchResult): string {
+  return result.skills.map((s) => s.name).join("\n");
+}