mcp-lyricscom 1.4.0 → 2.0.0

package/dist/index.js

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import process3 from "process";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// src/config.ts
+import process from "process";
+
 // src/version.ts
-var PKG_VERSION = "1.4.0";
+var PKG_VERSION = "2.0.0";
 var REPO_URL = "https://github.com/smeet666/mcp-lyricscom";
 
 // src/config.ts
@@ -21,7 +25,9 @@ var MIN_ALLOWED_INTERVAL_MS = 500;
 var LOG_LEVELS = ["silent", "error", "info", "debug"];
 function readNumber(name, env, range) {
   const raw = env[name];
-  if (raw === void 0 || raw.trim() === "") return range.fallback;
+  if (raw === void 0 || raw.trim() === "") {
+    return range.fallback;
+  }
   const parsed = Number(raw);
   if (!Number.isFinite(parsed)) {
     warn(`${name}="${raw}" is not a number, using ${range.fallback}`);
@@ -39,7 +45,9 @@ function warn(message) {
 }
 function readInterval(env) {
   const raw = env.LYRICSCOM_MIN_INTERVAL_MS;
-  if (raw === void 0 || raw.trim() === "") return DEFAULTS.minIntervalMs;
+  if (raw === void 0 || raw.trim() === "") {
+    return DEFAULTS.minIntervalMs;
+  }
   const parsed = Number(raw);
   if (!Number.isFinite(parsed)) {
     warn(`LYRICSCOM_MIN_INTERVAL_MS="${raw}" is not a number, using ${DEFAULTS.minIntervalMs}ms`);
@@ -121,7 +129,9 @@ var TtlLruCache = class {
   store = /* @__PURE__ */ new Map();
   get(key) {
     const entry = this.store.get(key);
-    if (!entry) return void 0;
+    if (!entry) {
+      return void 0;
+    }
     if (Date.now() >= entry.expiresAt) {
       this.store.delete(key);
       return void 0;
@@ -131,12 +141,16 @@ var TtlLruCache = class {
     return entry.value;
   }
   set(key, value) {
-    if (this.maxEntries <= 0 || this.ttlMs <= 0) return;
+    if (this.maxEntries <= 0 || this.ttlMs <= 0) {
+      return;
+    }
     this.store.delete(key);
     this.store.set(key, { value, expiresAt: Date.now() + this.ttlMs });
     while (this.store.size > this.maxEntries) {
       const oldest = this.store.keys().next();
-      if (oldest.done) break;
+      if (oldest.done) {
+        break;
+      }
       this.store.delete(oldest.value);
     }
   }
@@ -201,17 +215,32 @@ function invalidInput(message, hint) {
 }
 
 // src/lyricscom/parsers/detectThrottle.ts
+var CLOSING_HTML_TAG = /<\/html>/i;
 var MIN_PLAUSIBLE_HTML = 2e3;
 function classifyResponse(status, body) {
-  if (status === 202) return { kind: "throttled", reason: "status-202" };
-  if (status === 429) return { kind: "throttled", reason: "status-429" };
-  if (status === 503) return { kind: "throttled", reason: "status-503" };
-  if (status === 403) return { kind: "blocked", status };
-  if (status === 404) return { kind: "not-found" };
-  if (status >= 500) return { kind: "server-error", status };
+  if (status === 202) {
+    return { kind: "throttled", reason: "status-202" };
+  }
+  if (status === 429) {
+    return { kind: "throttled", reason: "status-429" };
+  }
+  if (status === 503) {
+    return { kind: "throttled", reason: "status-503" };
+  }
+  if (status === 403) {
+    return { kind: "blocked", status };
+  }
+  if (status === 404) {
+    return { kind: "not-found" };
+  }
+  if (status >= 500) {
+    return { kind: "server-error", status };
+  }
   const trimmed = body.trim();
-  if (trimmed.length === 0) return { kind: "throttled", reason: "empty-body" };
-  if (trimmed.length < MIN_PLAUSIBLE_HTML && !/<\/html>/i.test(trimmed)) {
+  if (trimmed.length === 0) {
+    return { kind: "throttled", reason: "empty-body" };
+  }
+  if (trimmed.length < MIN_PLAUSIBLE_HTML && !CLOSING_HTML_TAG.test(trimmed)) {
     return { kind: "throttled", reason: "short-body" };
   }
   return { kind: "ok", html: body };
@@ -267,10 +296,14 @@ var RateLimiter = class {
     this.intervalMs = Math.max(this.baseIntervalMs, Math.floor(this.intervalMs * 0.75));
   }
   async waitForSlot() {
-    if (this.intervalMs === 0 || this.lastStart === 0) return;
+    if (this.intervalMs === 0 || this.lastStart === 0) {
+      return;
+    }
     const elapsed = Date.now() - this.lastStart;
     const remaining = Math.min(this.intervalMs, this.intervalMs - elapsed);
-    if (remaining > 0) await sleep(remaining);
+    if (remaining > 0) {
+      await sleep(remaining);
+    }
   }
 };
 function sleep(ms) {
@@ -289,7 +322,7 @@ function backoffDelay(attempt, random = Math.random) {
 async function fetchHtml(url, deps) {
   const { config, limiter, logger } = deps;
   const doFetch = deps.fetchImpl ?? fetch;
-  return limiter.schedule(async () => {
+  return await limiter.schedule(async () => {
     let lastError;
     let askedWaitMs = null;
     for (let attempt = 0; attempt <= config.maxRetries; attempt += 1) {
@@ -349,21 +382,38 @@ async function fetchHtml(url, deps) {
           throw blockedUserAgent(url);
         case "not-found":
           throw notFound(url);
+        // Every kind the classifier declares is handled above, and the linter
+        // holds that. This clause is the runtime backstop: a response nothing
+        // above matched leaves as an error rather than as a silent retry.
+        default:
+          throw new LyricsComError(
+            "network_error",
+            `lyrics.com returned a response this client cannot classify for ${url}.`,
+            { url }
+          );
       }
     }
     throw lastError ?? new LyricsComError("network_error", `Could not fetch ${url}.`, { url });
   });
 }
 function parseRetryAfter(raw) {
-  if (!raw) return null;
+  if (!raw) {
+    return null;
+  }
   const seconds = Number(raw.trim());
-  if (Number.isFinite(seconds) && seconds >= 0) return Math.round(seconds * 1e3);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return Math.round(seconds * 1e3);
+  }
   const when = Date.parse(raw);
-  if (Number.isNaN(when)) return null;
+  if (Number.isNaN(when)) {
+    return null;
+  }
   return Math.max(0, when - Date.now());
 }
 function asTransportError(error, url) {
-  if (error instanceof LyricsComError) return error;
+  if (error instanceof LyricsComError) {
+    return error;
+  }
   const name = error instanceof Error ? error.name : "";
   if (name === "TimeoutError" || name === "AbortError") {
     return new LyricsComError("timeout", "lyrics.com did not answer in time.", {
@@ -376,9 +426,11 @@ function asTransportError(error, url) {
 }
 
 // src/lyricscom/parsers/searchResults.ts
-import * as cheerio from "cheerio";
+import process2 from "process";
+import { load } from "cheerio";
 
 // src/text/normalize.ts
+var MOJIBAKE_MARKS = /[ÃÂ]/;
 var HTML_ENTITIES = {
   amp: "&",
   lt: "<",
@@ -395,12 +447,16 @@ var HTML_ENTITIES = {
   rdquo: "\u201D"
 };
 function unescapeHtml(text) {
-  if (!text) return text;
+  if (!text) {
+    return text;
+  }
   return text.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*);/g, (match, entity) => {
     if (entity.startsWith("#")) {
       const isHex = entity[1] === "x" || entity[1] === "X";
       const codePoint = Number.parseInt(isHex ? entity.slice(2) : entity.slice(1), isHex ? 16 : 10);
-      if (Number.isNaN(codePoint) || codePoint < 0 || codePoint > 1114111) return match;
+      if (Number.isNaN(codePoint) || codePoint < 0 || codePoint > 1114111) {
+        return match;
+      }
       try {
         return String.fromCodePoint(codePoint);
       } catch {
@@ -411,10 +467,14 @@ function unescapeHtml(text) {
   });
 }
 function fixEncodingIssues(text) {
-  if (!text || !/[ÃÂ]/.test(text)) return text;
+  if (!(text && MOJIBAKE_MARKS.test(text))) {
+    return text;
+  }
   try {
     const repaired = Buffer.from(text, "latin1").toString("utf8");
-    if (repaired.includes("\uFFFD")) return text;
+    if (repaired.includes("\uFFFD")) {
+      return text;
+    }
     return repaired;
   } catch {
     return text;
@@ -424,23 +484,33 @@ function collapseWhitespace(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function cleanInlineText(text) {
-  if (!text) return "";
+  if (!text) {
+    return "";
+  }
   return collapseWhitespace(fixEncodingIssues(unescapeHtml(text)));
 }
 function cleanLyricsText(text) {
-  if (!text) return "";
+  if (!text) {
+    return "";
+  }
   const normalized = fixEncodingIssues(unescapeHtml(text)).replace(/\r\n?/g, "\n");
   const lines = normalized.split("\n").map((line) => line.trim());
   const out = [];
   for (const line of lines) {
-    if (line === "" && (out.length === 0 || out[out.length - 1] === "")) continue;
+    if (line === "" && (out.length === 0 || out.at(-1) === "")) {
+      continue;
+    }
     out.push(line);
   }
-  while (out.length > 0 && out[out.length - 1] === "") out.pop();
+  while (out.length > 0 && out.at(-1) === "") {
+    out.pop();
+  }
   return out.join("\n");
 }
 
 // src/lyricscom/urls.ts
+var ABSOLUTE_URL = /^https?:\/\//i;
+var DIGITS_ONLY = /^\d+$/;
 var BASE_URL = "https://www.lyrics.com";
 var RESULTS_PER_PAGE = 24;
 var SONG_HREF_RE = /^\/lyric(?:-lf)?\/(\d+)\//;
@@ -450,7 +520,9 @@ function encodeTerm(term) {
 }
 function buildSearchUrl(term, page) {
   const encoded = encodeTerm(term);
-  if (page <= 1) return `${BASE_URL}/lyrics/${encoded}`;
+  if (page <= 1) {
+    return `${BASE_URL}/lyrics/${encoded}`;
+  }
   return `${BASE_URL}/serp.php?st=${encoded}&p=${page}`;
 }
 function buildSongUrl(id) {
@@ -463,22 +535,28 @@ function isLyricsComHost(rawUrl) {
   } catch {
     return false;
   }
-  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return false;
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    return false;
+  }
   return ALLOWED_HOSTS.has(parsed.hostname.toLowerCase());
 }
 function extractSongId(hrefOrUrl) {
   let path = hrefOrUrl;
-  if (/^https?:\/\//i.test(hrefOrUrl)) {
-    if (!isLyricsComHost(hrefOrUrl)) return null;
+  if (ABSOLUTE_URL.test(hrefOrUrl)) {
+    if (!isLyricsComHost(hrefOrUrl)) {
+      return null;
+    }
     path = new URL(hrefOrUrl).pathname;
   }
-  if (!path.startsWith("/")) path = `/${path}`;
+  if (!path.startsWith("/")) {
+    path = `/${path}`;
+  }
   const match = SONG_HREF_RE.exec(path);
   return match?.[1] ?? null;
 }
 function resolveSongRef(input) {
   if (input.id) {
-    if (!/^\d+$/.test(input.id)) {
+    if (!DIGITS_ONLY.test(input.id)) {
       throw invalidInput(
         `"${input.id}" is not a lyrics.com song id.`,
         "Ids are digits only, as returned by the search tools."
@@ -536,8 +614,9 @@ var SEL = {
 };
 
 // src/lyricscom/parsers/searchResults.ts
+var YEAR = /\b(1[89]\d{2}|20\d{2})\b/;
 function parseSearchResults(html, options) {
-  const $ = cheerio.load(html);
+  const $ = load(html);
   const rows = $(SEL.serpItem);
   if (rows.length === 0) {
     if ($(SEL.serpShell).length === 0) {
@@ -554,7 +633,7 @@ function parseSearchResults(html, options) {
     const title = cleanInlineText(titleLink.text());
     const artist = cleanInlineText(row.find(SEL.resultArtist).first().text());
     const id = href ? extractSongId(href) : null;
-    if (!id || !title || !artist) {
+    if (!(id && title && artist)) {
       skipped += 1;
       return;
     }
@@ -576,7 +655,7 @@ function parseSearchResults(html, options) {
     throw parseFailure(options.url, `${rows.length} result rows matched but none could be read`);
   }
   if (skipped > 0) {
-    process.stderr.write(
+    process2.stderr.write(
       `[mcp-lyricscom] skipped ${skipped} unreadable result rows on ${options.url}
 `
     );
@@ -589,20 +668,23 @@ function parseSearchResults(html, options) {
   };
 }
 function parseYear(raw) {
-  const match = /\b(1[89]\d{2}|20\d{2})\b/.exec(raw);
-  if (!match?.[1]) return null;
+  const match = YEAR.exec(raw);
+  if (!match?.[1]) {
+    return null;
+  }
   return Number.parseInt(match[1], 10);
 }
 
 // src/lyricscom/parsers/songPage.ts
-import * as cheerio2 from "cheerio";
+import { load as load2 } from "cheerio";
+var NO_LYRICS_FOUND = /no lyrics found/i;
 function parseSongPage(html, options) {
-  const $ = cheerio2.load(html);
+  const $ = load2(html);
   const title = cleanInlineText($(SEL.songTitle).first().text()) || null;
   const artist = cleanInlineText($(SEL.songArtist).first().text()) || null;
   const body = $(SEL.songBody).first();
   if (body.length === 0) {
-    const declaresNoLyrics = $(SEL.songNoData).length > 0 || /no lyrics found/i.test($("title").text());
+    const declaresNoLyrics = $(SEL.songNoData).length > 0 || NO_LYRICS_FOUND.test($("title").text());
     if (!declaresNoLyrics) {
       throw parseFailure(options.url, "no lyrics container and no 'no lyrics' marker");
     }
@@ -618,12 +700,13 @@ function extractBodyText($, body) {
   const rawHtml = $.html(body);
   const withoutAnchors = rawHtml.replace(/<a[^>]*>([\s\S]*?)<\/a>/gi, "$1");
   const withNewlines = withoutAnchors.replace(/<br\s*\/?>/gi, "\n");
-  return cheerio2.load(withNewlines).root().text();
+  return load2(withNewlines).root().text();
 }
 
 // src/lyricscom/client.ts
+var BROWSER_IDENTITY = /mozilla\/|applewebkit|chrome\/|safari\/|gecko/i;
 function withGuarantees(config) {
-  const userAgent = /mozilla\/|applewebkit|chrome\/|safari\/|gecko/i.test(config.userAgent) ? `${config.userAgent} ${DEFAULT_USER_AGENT}` : config.userAgent;
+  const userAgent = BROWSER_IDENTITY.test(config.userAgent) ? `${config.userAgent} ${DEFAULT_USER_AGENT}` : config.userAgent;
   return {
     ...config,
     userAgent,
@@ -645,11 +728,11 @@ var LyricsComClient = class {
   }
   async search(term, page) {
     const url = buildSearchUrl(term, page);
-    return this.fetchParsed(url, (html) => parseSearchResults(html, { page, url }));
+    return await this.fetchParsed(url, (html) => parseSearchResults(html, { page, url }));
   }
   async getSong(ref) {
     const { id, url } = resolveSongRef(ref);
-    return this.fetchParsed(url, (html) => parseSongPage(html, { id, url }));
+    return await this.fetchParsed(url, (html) => parseSongPage(html, { id, url }));
   }
   /**
    * Fetch, parse, then cache. In that order: a page that could not be read is
@@ -687,7 +770,9 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function getKeywordIndex(keyword, text) {
-  if (!keyword || !text) return -1;
+  if (!(keyword && text)) {
+    return -1;
+  }
   const escaped = escapeRegExp(keyword.toLowerCase());
   const haystack = text.toLowerCase();
   const passes = [
@@ -709,11 +794,15 @@ function containsWord(keyword, text) {
 
 // src/text/excerpt.ts
 function findMatchingLine(text, keyword) {
-  if (!text || !keyword) return null;
+  if (!(text && keyword)) {
+    return null;
+  }
   const lines = text.split("\n");
   for (let i = 0; i < lines.length; i += 1) {
     const line = lines[i] ?? "";
-    if (line.trim() === "") continue;
+    if (line.trim() === "") {
+      continue;
+    }
     if (getKeywordIndex(keyword, line) !== -1) {
       return { line: line.trim(), lineNumber: i + 1 };
     }
@@ -722,11 +811,17 @@ function findMatchingLine(text, keyword) {
 }
 function matchedLineExcerpt(text, keyword, options = {}) {
   const maxChars = options.maxChars ?? 160;
-  if (!text) return null;
+  if (!text) {
+    return null;
+  }
   const match = findMatchingLine(text, keyword);
   const line = match?.line ?? text.split("\n").find((candidate) => candidate.trim() !== "")?.trim();
-  if (!line) return null;
-  if (line.length <= maxChars) return line;
+  if (!line) {
+    return null;
+  }
+  if (line.length <= maxChars) {
+    return line;
+  }
   const keywordAt = match ? Math.max(getKeywordIndex(keyword, line), 0) : 0;
   const start = Math.max(0, keywordAt - Math.floor(maxChars / 2));
   const end = Math.min(line.length, start + maxChars);
@@ -737,10 +832,24 @@ function matchedLineExcerpt(text, keyword, options = {}) {
 // src/tools/arguments.ts
 import { z } from "zod";
 var INVALID_INPUT = "invalid_input";
+var defaultMessage = z.core.locales.en().localeError;
 function strictInput(shape) {
   const declared = Object.keys(shape);
-  const errorMap = (issue, ctx) => issue.code === z.ZodIssueCode.unrecognized_keys ? { message: unknownArgumentMessage(issue.keys, declared) } : { message: ctx.defaultError };
-  return z.strictObject(shape, { errorMap });
+  const refuse = (issue) => issue.code === "unrecognized_keys" ? unknownArgumentMessage(issue.keys, declared) : `[${INVALID_INPUT}] ${defaultMessage(issue)}`;
+  for (const argument of Object.values(shape)) {
+    carryTheCode(argument, refuse);
+  }
+  return z.strictObject(shape, { error: refuse });
+}
+function carryTheCode(schema, refuse) {
+  const definition = schema._zod.def;
+  definition.error = refuse;
+  for (const check of definition.checks ?? []) {
+    check._zod.def.error = refuse;
+  }
+  if (definition.innerType) {
+    carryTheCode(definition.innerType, refuse);
+  }
 }
 function unknownArgumentMessage(keys, declared) {
   const named = keys.map((key) => {
@@ -752,15 +861,21 @@ function unknownArgumentMessage(keys, declared) {
 function nearestArgument(key, declared) {
   const flatten = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
   const flat = flatten(key);
-  if (flat.length === 0) return void 0;
+  if (flat.length === 0) {
+    return void 0;
+  }
   const sameName = declared.find((name) => flatten(name) === flat);
-  if (sameName) return sameName;
+  if (sameName) {
+    return sameName;
+  }
   const overlapping = declared.find((name) => {
     const other = flatten(name);
     const [shorter, longer] = other.length < flat.length ? [other, flat] : [flat, other];
     return shorter.length >= 3 && (longer.startsWith(shorter) || longer.endsWith(shorter));
   });
-  if (overlapping) return overlapping;
+  if (overlapping) {
+    return overlapping;
+  }
   let closest;
   let shortest = Number.POSITIVE_INFINITY;
   for (const name of declared) {
@@ -774,15 +889,25 @@ function nearestArgument(key, declared) {
 }
 function editDistance(left, right) {
   let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  let distance = right.length;
   for (let row = 1; row <= left.length; row += 1) {
     const current = [row];
-    for (let column = 1; column <= right.length; column += 1) {
-      const substitution = previous[column - 1] + (left[row - 1] === right[column - 1] ? 0 : 1);
-      current[column] = Math.min(substitution, previous[column] + 1, current[column - 1] + 1);
+    let diagonal = row - 1;
+    let leftward = row;
+    for (const [column, above] of previous.entries()) {
+      if (column === 0) {
+        continue;
+      }
+      const substitution = diagonal + (left[row - 1] === right[column - 1] ? 0 : 1);
+      const cell = Math.min(substitution, above + 1, leftward + 1);
+      current.push(cell);
+      diagonal = above;
+      leftward = cell;
     }
     previous = current;
+    distance = leftward;
   }
-  return previous[right.length];
+  return distance;
 }
 
 // src/tools/shared.ts
@@ -826,12 +951,18 @@ ${trailer}` : body }],
 function toToolError(error) {
   const known = error instanceof LyricsComError ? error : new LyricsComError("network_error", error instanceof Error ? error.message : String(error));
   const lines = [`[${known.code}] ${known.message}`];
-  if (known.details.hint) lines.push(`Hint: ${known.details.hint}`);
-  if (known.details.url) lines.push(`URL: ${known.details.url}`);
+  if (known.details.hint) {
+    lines.push(`Hint: ${known.details.hint}`);
+  }
+  if (known.details.url) {
+    lines.push(`URL: ${known.details.url}`);
+  }
   return { content: [{ type: "text", text: lines.join("\n") }], isError: true };
 }
 function truncate(text, maxChars) {
-  if (text.length <= maxChars) return text;
+  if (text.length <= maxChars) {
+    return text;
+  }
   return `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
 }
 function renderResultList(results) {
@@ -845,6 +976,24 @@ function renderResultList(results) {
 }
 
 // src/tools/getLyrics.ts
+function howFarTheTextGoes(pastTheEnd, offset, nextOffset) {
+  if (pastTheEnd) {
+    return `Nothing at offset=${offset}: that is past the end. Call again with offset=0.`;
+  }
+  if (nextOffset === null) {
+    return "Complete.";
+  }
+  return `Truncated: call again with offset=${nextOffset} to continue.`;
+}
+function whereTheWordIs(highlight) {
+  if (!highlight) {
+    return "";
+  }
+  if (!highlight.found) {
+    return `"${highlight.word}" does not appear in these lyrics.`;
+  }
+  return `"${highlight.word}" appears on line ${highlight.line_number}.`;
+}
 var getLyricsDescription = [
   "Fetch the full lyrics of one song from lyrics.com, given the song id or URL returned by search_lyrics or search_songs.",
   "Lyrics can be long, so the response is truncated by default: check 'truncated' and call again with 'offset' set to",
@@ -888,9 +1037,13 @@ var getLyricsOutputShape = {
   notes: z3.array(z3.string())
 };
 function sliceAtLineBoundary(text, offset, maxChars) {
-  if (offset >= text.length) return { slice: "", nextOffset: null };
+  if (offset >= text.length) {
+    return { slice: "", nextOffset: null };
+  }
   const remaining = text.slice(offset);
-  if (remaining.length <= maxChars) return { slice: remaining, nextOffset: null };
+  if (remaining.length <= maxChars) {
+    return { slice: remaining, nextOffset: null };
+  }
   const window = remaining.slice(0, maxChars);
   const lastBreak = window.lastIndexOf("\n");
   const cut = lastBreak > 0 ? lastBreak : maxChars;
@@ -899,11 +1052,16 @@ function sliceAtLineBoundary(text, offset, maxChars) {
 async function runGetLyrics(client, args) {
   try {
     const ref = {};
-    if (args.id) ref.id = args.id;
-    else if (args.url) ref.url = args.url;
+    if (args.id) {
+      ref.id = args.id;
+    } else if (args.url) {
+      ref.url = args.url;
+    }
     const { data, cached } = await client.getSong(ref);
     const notes = [];
-    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    if (cached) {
+      notes.push("Served from this server's short-lived in-memory cache.");
+    }
     const credit = [data.title, data.artist].filter(Boolean).join(" \u2014 ");
     const attribution = `${credit || "Lyrics"} via lyrics.com \u2014 ${data.url}`;
     if (!data.hasLyrics) {
@@ -965,8 +1123,8 @@ ${attribution}`
     const summary = [
       attribution,
       `${structured.line_count} lines, ${structured.total_chars} characters.`,
-      pastTheEnd ? `Nothing at offset=${args.offset}: that is past the end. Call again with offset=0.` : nextOffset !== null ? `Truncated: call again with offset=${nextOffset} to continue.` : "Complete.",
-      structured.highlight ? structured.highlight.found ? `"${structured.highlight.word}" appears on line ${structured.highlight.line_number}.` : `"${structured.highlight.word}" does not appear in these lyrics.` : ""
+      howFarTheTextGoes(pastTheEnd, args.offset, nextOffset),
+      whereTheWordIs(structured.highlight)
     ].filter(Boolean).join("\n");
     return ok(structured, truncate(`${summary}
 
@@ -991,7 +1149,9 @@ function dedupeSongs(songs) {
   const unique = [];
   for (const song of songs) {
     const key = songKey(song.artist, song.title);
-    if (seen.has(key)) continue;
+    if (seen.has(key)) {
+      continue;
+    }
     seen.add(key);
     unique.push(song);
   }
@@ -1000,6 +1160,49 @@ function dedupeSongs(songs) {
 
 // src/tools/searchLyrics.ts
 var MAX_FULL_VERIFICATIONS = 5;
+async function keepTheOnesCarryingTheWords(client, args, unique, notes) {
+  const kept = [];
+  let filteredOut = 0;
+  let fullChecks = 0;
+  for (const song of unique) {
+    if (kept.length >= args.limit) {
+      break;
+    }
+    let text = song.snippet ?? "";
+    if (args.verify === "full" && fullChecks < MAX_FULL_VERIFICATIONS) {
+      fullChecks += 1;
+      try {
+        const page = await client.getSong({ id: song.id });
+        if (page.data.hasLyrics) {
+          text = page.data.lyrics;
+        }
+      } catch {
+        notes.push(`Could not verify "${song.title}" against its full lyrics.`);
+      }
+    }
+    const matches = args.verify === "none" || text !== "" && containsWord(args.query, text);
+    if (!matches) {
+      filteredOut += 1;
+      continue;
+    }
+    const excerpt = args.include_excerpt && text ? matchedLineExcerpt(text, args.query, { maxChars: 160 }) : null;
+    kept.push({ song, excerpt });
+  }
+  return { kept, filteredOut };
+}
+function whatFollowsThisPage(hasMore, page) {
+  if (!hasMore) {
+    return "";
+  }
+  if (page < MAX_PAGE) {
+    return `
+
+More results available: call again with page=${page + 1}.`;
+  }
+  return `
+
+lyrics.com holds more, but page ${MAX_PAGE} is as far as this tool reads. Narrow the query instead.`;
+}
 var searchLyricsDescription = [
   "Search lyrics.com for songs whose lyrics contain a given word or phrase.",
   "Returns matching songs with artist, title, a short excerpt of the line where the word appears,",
@@ -1033,32 +1236,11 @@ async function runSearchLyrics(client, args) {
   try {
     const { data, cached } = await client.search(args.query, args.page);
     const notes = [];
-    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
-    const unique = dedupeSongs(data.results);
-    const kept = [];
-    let filteredOut = 0;
-    let fullChecks = 0;
-    for (const song of unique) {
-      if (kept.length >= args.limit) break;
-      let text = song.snippet ?? "";
-      if (args.verify === "full" && fullChecks < MAX_FULL_VERIFICATIONS) {
-        fullChecks += 1;
-        try {
-          const page = await client.getSong({ id: song.id });
-          if (page.data.hasLyrics) text = page.data.lyrics;
-        } catch (error) {
-          notes.push(`Could not verify "${song.title}" against its full lyrics.`);
-          void error;
-        }
-      }
-      const matches = args.verify === "none" || text !== "" && containsWord(args.query, text);
-      if (!matches) {
-        filteredOut += 1;
-        continue;
-      }
-      const excerpt = args.include_excerpt && text ? matchedLineExcerpt(text, args.query, { maxChars: 160 }) : null;
-      kept.push({ song, excerpt });
+    if (cached) {
+      notes.push("Served from this server's short-lived in-memory cache.");
     }
+    const unique = dedupeSongs(data.results);
+    const { kept, filteredOut } = await keepTheOnesCarryingTheWords(client, args, unique, notes);
     if (args.verify === "full" && unique.length > MAX_FULL_VERIFICATIONS) {
       notes.push(
         `Full verification is capped at ${MAX_FULL_VERIFICATIONS} songs per call to avoid rate limiting; the remaining results were checked against their search excerpt.`
@@ -1082,11 +1264,7 @@ async function runSearchLyrics(client, args) {
       notes
     };
     const header = results.length > 0 ? `${results.length} song(s) on page ${args.page} for "${args.query}":` : `No song on page ${args.page} matched "${args.query}".`;
-    const footer = data.hasMore && args.page < MAX_PAGE ? `
-
-More results available: call again with page=${args.page + 1}.` : data.hasMore ? `
-
-lyrics.com holds more, but page ${MAX_PAGE} is as far as this tool reads. Narrow the query instead.` : "";
+    const footer = whatFollowsThisPage(data.hasMore, args.page);
     return ok(structured, `${header}
 ${renderResultList(results)}${footer}`);
   } catch (error) {
@@ -1096,6 +1274,28 @@ ${renderResultList(results)}${footer}`);
 
 // src/tools/searchSongs.ts
 import { z as z5 } from "zod";
+function whatFollowsThisPage2(hasMore, page) {
+  if (!hasMore) {
+    return "";
+  }
+  if (page < MAX_PAGE) {
+    return `
+
+More results available: call again with page=${page + 1}.`;
+  }
+  return `
+
+lyrics.com holds more, but page ${MAX_PAGE} is as far as this tool reads. Narrow the query instead.`;
+}
+function headerFor(found, loose, page, title) {
+  if (found === 0) {
+    return `No song on page ${page} matched "${title}".`;
+  }
+  if (loose) {
+    return `${found} song(s) lyrics.com offers on page ${page} for "${title}":`;
+  }
+  return `${found} song(s) on page ${page} matching "${title}":`;
+}
 var searchSongsDescription = [
   "Find songs on lyrics.com by their title.",
   "Returns candidate songs with artist, album, year, and the lyrics.com id and URL.",
@@ -1131,17 +1331,27 @@ function normalizeTitle(title) {
 function titleScore(candidate, query) {
   const a = normalizeTitle(candidate);
   const b = normalizeTitle(query);
-  if (!a || !b) return 0;
-  if (a === b) return 3;
-  if (a.startsWith(b)) return 2;
-  if (a.includes(b)) return 1;
+  if (!(a && b)) {
+    return 0;
+  }
+  if (a === b) {
+    return 3;
+  }
+  if (a.startsWith(b)) {
+    return 2;
+  }
+  if (a.includes(b)) {
+    return 1;
+  }
   return 0;
 }
 async function runSearchSongs(client, args) {
   try {
     const { data, cached } = await client.search(args.title, args.page);
     const notes = [];
-    if (cached) notes.push("Served from this server's short-lived in-memory cache.");
+    if (cached) {
+      notes.push("Served from this server's short-lived in-memory cache.");
+    }
     const artistFilter = args.artist?.trim().toLowerCase() ?? null;
     const unique = dedupeSongs(data.results);
     const scored = [];
@@ -1175,12 +1385,8 @@ async function runSearchSongs(client, args) {
       notes
     };
     const loose = args.match !== "strict";
-    const header = results.length > 0 ? loose ? `${results.length} song(s) lyrics.com offers on page ${args.page} for "${args.title}":` : `${results.length} song(s) on page ${args.page} matching "${args.title}":` : `No song on page ${args.page} matched "${args.title}".`;
-    const footer = data.hasMore && args.page < MAX_PAGE ? `
-
-More results available: call again with page=${args.page + 1}.` : data.hasMore ? `
-
-lyrics.com holds more, but page ${MAX_PAGE} is as far as this tool reads. Narrow the query instead.` : "";
+    const header = headerFor(results.length, loose, args.page, args.title);
+    const footer = whatFollowsThisPage2(data.hasMore, args.page);
     if (results.length > 0 && loose) {
       notes.push(
         `These are lyrics.com's own suggestions for "${args.title}", not rows whose title matches it. Check each title before quoting one, or ask again with match="strict".`
@@ -1261,16 +1467,16 @@ async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   const shutdown = () => {
-    void server.close().finally(() => process.exit(0));
+    server.close().catch(() => void 0).finally(() => process3.exit(0));
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process3.on("SIGINT", shutdown);
+  process3.on("SIGTERM", shutdown);
 }
 main().catch((error) => {
-  process.stderr.write(
+  process3.stderr.write(
     `[mcp-lyricscom] fatal: ${error instanceof Error ? error.stack ?? error.message : String(error)}
 `
   );
-  process.exit(1);
+  process3.exit(1);
 });
 //# sourceMappingURL=index.js.map