github-search-cli 9.8.2 → 9.9.0

package/dist/cli.js

@@ -16,6 +16,22 @@ var NetworkError = class extends SearchCliError {
     this.name = "NetworkError";
   }
 };
+var AuthError = class extends SearchCliError {
+  constructor() {
+    const msg = "\u26A0 Bad GitHub token (401). Press [t] to fix it, [u] to search without one";
+    super("GitHub API returned 401 (invalid or revoked token)", msg);
+    this.name = "AuthError";
+  }
+};
+var ForbiddenError = class extends SearchCliError {
+  constructor(detail = "GitHub API returned 403") {
+    const msg = `\u26A0 Forbidden (403) \u2014 ${detail}. Common causes: org SSO not authorizing the token, or a secondary rate limit. Press [t] to change the token`;
+    super(msg, msg);
+    this.detail = detail;
+    this.name = "ForbiddenError";
+  }
+  detail;
+};
 var RateLimitError = class extends SearchCliError {
   constructor(hasToken, resetSeconds) {
     const msg = hasToken ? `\u26A0 API rate limit exceeded (5,000/hr). Resets in ${resetSeconds ?? "?"}s. [r]etry [c]hange token` : "\u26A0 Rate limited (60/hr). Set GITHUB_TOKEN for 5,000/hr. [r]etry";
@@ -25,16 +41,36 @@ var RateLimitError = class extends SearchCliError {
   }
   hasToken;
 };
+var BadQueryError = class extends SearchCliError {
+  /** A concrete, corrected query the user can retry with. */
+  constructor(detail, hint) {
+    super(
+      `Invalid query: ${detail}`,
+      hint ? `\u26A0 Invalid query: ${detail}
+  Try: ${hint}` : `\u26A0 Invalid query: ${detail}`
+    );
+    this.detail = detail;
+    this.hint = hint;
+    this.name = "BadQueryError";
+  }
+  detail;
+  hint;
+};
 var NoResultsError = class extends SearchCliError {
-  constructor(query) {
+  /** Concrete loosened queries to retry, most promising first. */
+  constructor(query, relaxations = []) {
+    const tips = relaxations.length ? relaxations.map((r) => `Try: ${r}`).join("\n  ") : "Tips: check spelling, try fewer qualifiers, or [b]rowse trending";
     super(
-      `No results for "${query}"`,
-      `\u{1F50D} No results for "${query}". Tips: check spelling, try fewer qualifiers, or [b]rowse trending`
+      relaxations.length > 0 ? `No results for "${query}" \u2014 try loosening: ${relaxations.join(" / ")}` : `No results for "${query}"`,
+      `\u{1F50D} No results for "${query}".
+  ${tips}`
     );
     this.query = query;
+    this.relaxations = relaxations;
     this.name = "NoResultsError";
   }
   query;
+  relaxations;
 };
 var ParseError = class extends SearchCliError {
   constructor(source, detail) {
@@ -195,9 +231,11 @@ function normalizeEnvelope(env) {
 var KNOWN_QUALIFIERS = [
   "language",
   "stars",
+  "forks",
   "fork",
   "archived",
   "topic",
+  "topics",
   "user",
   "org",
   "repo",
@@ -207,8 +245,80 @@ var KNOWN_QUALIFIERS = [
   "in",
   "size",
   "license",
-  "created"
+  "created",
+  "followers"
 ];
+var KNOWN_QUALIFIER_SET = new Set(KNOWN_QUALIFIERS);
+var QUALIFIER_ALIASES = {
+  // language
+  langauge: "language",
+  lang: "language",
+  languge: "language",
+  // stars / forks
+  star: "stars",
+  strs: "stars",
+  forke: "forks",
+  // topic
+  topc: "topic",
+  tpics: "topic",
+  // user / org
+  usr: "user",
+  ogranization: "org",
+  orginzation: "org",
+  // date qualifiers
+  push: "pushed",
+  creat: "created",
+  updat: "updated",
+  // visibility
+  visiblity: "visibility",
+  visability: "visibility",
+  // license
+  licence: "license",
+  // size
+  siz: "size",
+  // archived
+  archive: "archived"
+};
+function editDistanceWithin(a, b, max) {
+  if (a === b) return 0;
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const curr = [i];
+    let rowMin = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+      if (curr[j] < rowMin) rowMin = curr[j];
+    }
+    if (rowMin > max) return max + 1;
+    prev = curr;
+  }
+  return prev[b.length];
+}
+function resolveQualifierKey(key) {
+  const k = key.toLowerCase();
+  if (KNOWN_QUALIFIER_SET.has(k)) return k;
+  const alias = QUALIFIER_ALIASES[k];
+  if (alias) return alias;
+  if (k.length < 4) return k;
+  const maxDistance = k.length <= 5 ? 1 : 2;
+  let best;
+  let bestDistance = maxDistance + 1;
+  let ties = 0;
+  for (const known of KNOWN_QUALIFIERS) {
+    const d = editDistanceWithin(k, known, maxDistance);
+    if (d < bestDistance) {
+      bestDistance = d;
+      best = known;
+      ties = 1;
+      if (d === 0) break;
+    } else if (d === bestDistance && best !== void 0) {
+      ties++;
+    }
+  }
+  return best !== void 0 && ties === 1 ? best : k;
+}
 var QUALIFIER_SUGGESTIONS = {
   l: ["language:"],
   s: ["stars:", "size:"],
@@ -224,13 +334,164 @@ var QUALIFIER_SUGGESTIONS = {
   a: ["archived:"]
 };
 function suggestFor(input) {
-  const trimmed = input.trim().toLowerCase();
+  const trimmed = input.trim().toLowerCase().replace(/:$/, "");
   if (trimmed.length === 0) return [];
   if (trimmed.length === 1 && QUALIFIER_SUGGESTIONS[trimmed]) {
     return QUALIFIER_SUGGESTIONS[trimmed];
   }
-  const matches = KNOWN_QUALIFIERS.filter((k) => k.startsWith(trimmed));
-  return matches.map((k) => `${k}:`);
+  const resolved = resolveQualifierKey(trimmed);
+  const aliasHit = resolved !== trimmed && KNOWN_QUALIFIER_SET.has(resolved) ? [`${resolved}:`] : [];
+  const matches = KNOWN_QUALIFIERS.filter(
+    (k) => k.startsWith(trimmed) && !aliasHit.includes(`${k}:`)
+  ).map((k) => `${k}:`);
+  return [...aliasHit, ...matches];
+}
+var NUMERIC_QUALIFIERS = /* @__PURE__ */ new Set([
+  "forks",
+  "size",
+  "stars",
+  "topics",
+  "followers"
+]);
+var BOOLEAN_QUALIFIERS = /* @__PURE__ */ new Set(["archived"]);
+var VISIBILITY_VALUES = /* @__PURE__ */ new Set(["public", "private", "internal"]);
+var IN_FIELDS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "topics",
+  "readme",
+  "comments"
+]);
+var DATE_QUALIFIERS = /* @__PURE__ */ new Set(["created", "pushed", "updated"]);
+var COMPARISON_OPERATORS = [">=", "<=", ">", "<"];
+function redactToken(url, token) {
+  return token ? url.replace(token, "<token>") : url;
+}
+function splitComparison(value) {
+  for (const op of COMPARISON_OPERATORS) {
+    if (value.startsWith(op)) {
+      return { op, rest: value.slice(op.length) };
+    }
+  }
+  return { op: "", rest: value };
+}
+function parseCount(raw) {
+  const trimmed = raw.trim().replace(/_/g, "");
+  if (trimmed === "") return null;
+  const match = /^(\d+(?:\.\d+)?)([km])?$/i.exec(trimmed);
+  if (!match) return null;
+  if (!match[2] && match[1].includes(".")) return null;
+  const base = Number.parseFloat(match[1]);
+  if (!Number.isFinite(base)) return null;
+  const suffix = match[2]?.toLowerCase();
+  const multiplier = suffix === "k" ? 1e3 : suffix === "m" ? 1e6 : 1;
+  return Math.floor(base * multiplier);
+}
+function isValidISODate(raw) {
+  const trimmed = raw.trim();
+  const m = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2}))?(?:Z|[+-]\d{2}:?\d{2})?)?$/.exec(
+    trimmed
+  );
+  if (!m) return false;
+  const [, y, mo, d, h = "0", mi = "0", s = "0"] = m;
+  const year = Number(y);
+  const month = Number(mo);
+  const day = Number(d);
+  if (month < 1 || month > 12) return false;
+  if (day < 1 || day > 31) return false;
+  if (Number(h) > 23 || Number(mi) > 59 || Number(s) > 59) return false;
+  const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
+  return day <= daysInMonth;
+}
+function normalizeQualifierValue(key, value) {
+  const normalizedKey = key.toLowerCase();
+  if (!NUMERIC_QUALIFIERS.has(normalizedKey)) return value;
+  if (value === "") return value;
+  const { op, rest } = splitComparison(value);
+  const rangeIdx = rest.indexOf("..");
+  if (rangeIdx > 0) {
+    const lo = parseCount(rest.slice(0, rangeIdx));
+    const hi = parseCount(rest.slice(rangeIdx + 2));
+    if (lo === null || hi === null) return value;
+    return `${op}${lo}..${hi}`;
+  }
+  if (!/[km]$/i.test(rest.trim())) return value;
+  const count = parseCount(rest);
+  if (count === null) return value;
+  return `${op || ">="}${count}`;
+}
+function validateQualifierValue(key, value) {
+  const k = key.toLowerCase();
+  if (!KNOWN_QUALIFIER_SET.has(k)) return null;
+  if (value.trim() === "") {
+    return `"${key}:" needs a value (e.g. ${key}:<something>)`;
+  }
+  if (NUMERIC_QUALIFIERS.has(k)) {
+    const { rest } = splitComparison(value.trim());
+    const rangeIdx = rest.indexOf("..");
+    if (rangeIdx > 0) {
+      const lo = parseCount(rest.slice(0, rangeIdx));
+      const hi = parseCount(rest.slice(rangeIdx + 2));
+      if (lo === null || hi === null) {
+        return `"${key}:${value}" is not a valid range \u2014 use ${k}:100..500 or ${k}:>=100`;
+      }
+      if (lo > hi) {
+        return `"${key}:${value}" has a reversed range (${lo} > ${hi})`;
+      }
+      return null;
+    }
+    if (parseCount(rest) === null) {
+      return `"${key}:${value}" is not a number \u2014 use ${k}:100, ${k}:>=100, or ${k}:1k..10k`;
+    }
+    return null;
+  }
+  if (k === "fork") {
+    const v = value.trim().toLowerCase();
+    if (v !== "true" && v !== "false" && v !== "only") {
+      return `"fork:${value}" is not valid \u2014 use fork:true, fork:false, or fork:only`;
+    }
+    return null;
+  }
+  if (BOOLEAN_QUALIFIERS.has(k)) {
+    const v = value.trim().toLowerCase();
+    if (v !== "true" && v !== "false") {
+      return `"${key}:${value}" is not valid \u2014 use ${k}:true or ${k}:false`;
+    }
+    return null;
+  }
+  if (k === "visibility") {
+    const v = value.trim().toLowerCase();
+    if (!VISIBILITY_VALUES.has(v)) {
+      return `"visibility:${value}" is not valid \u2014 use visibility:public, visibility:private, or visibility:internal`;
+    }
+    return null;
+  }
+  if (k === "in") {
+    const parts = value.split(",").map((p) => p.trim().toLowerCase());
+    if (parts.some((p) => !IN_FIELDS.has(p))) {
+      const bad = parts.find((p) => !IN_FIELDS.has(p));
+      return `"in:${value}" is not valid \u2014 ${bad ? `"${bad}" is not a ` : ""}searchable field. Try in:name, in:description, in:topics, or in:readme`;
+    }
+    return null;
+  }
+  if (DATE_QUALIFIERS.has(k)) {
+    const trimmed = value.trim();
+    const { rest } = splitComparison(trimmed);
+    const rangeIdx = rest.indexOf("..");
+    if (rangeIdx > 0) {
+      const lo = rest.slice(0, rangeIdx);
+      const hi = rest.slice(rangeIdx + 2);
+      if (!isValidISODate(lo) || !isValidISODate(hi)) {
+        return `"${key}:${value}" is not a valid date range \u2014 use ${k}:2020-01-01..2024-01-01`;
+      }
+      return null;
+    }
+    if (!isValidISODate(rest)) {
+      return `"${key}:${value}" is not a valid date \u2014 use ${k}:2024-01-01 (optionally with >, >=, <, <=)`;
+    }
+    return null;
+  }
+  return null;
 }
 function tokenize(input) {
   const tokens = [];
@@ -258,22 +519,46 @@ function tokenize(input) {
   }
   return tokens;
 }
+var EMPTY_QUERY = {
+  keywords: [],
+  qualifiers: [],
+  raw: "",
+  corrections: []
+};
+function trendingQuery() {
+  return { ...EMPTY_QUERY, raw: "trending" };
+}
 function parseQuery(raw) {
   const trimmed = raw.trim();
   if (trimmed === "") {
-    return { keywords: [], qualifiers: [], raw };
+    return { keywords: [], qualifiers: [], raw, corrections: [] };
   }
   const keywords = [];
   const qualifiers = [];
+  const corrections = [];
   for (const token of tokenize(trimmed)) {
     const qualifier = matchQualifier(token);
     if (qualifier) {
-      qualifiers.push(qualifier);
+      const resolvedKey = resolveQualifierKey(qualifier.key);
+      const normalizedValue = normalizeQualifierValue(
+        resolvedKey,
+        qualifier.value
+      );
+      const original = `${qualifier.negated ? "-" : ""}${qualifier.key}:${qualifier.value}`;
+      const corrected = `${qualifier.negated ? "-" : ""}${resolvedKey}:${normalizedValue}`;
+      if (original !== corrected) {
+        corrections.push({ from: original, to: corrected });
+      }
+      qualifiers.push({
+        key: resolvedKey,
+        value: normalizedValue,
+        negated: qualifier.negated
+      });
     } else {
       keywords.push(token);
     }
   }
-  return { keywords, qualifiers, raw: trimmed };
+  return { keywords, qualifiers, raw: trimmed, corrections };
 }
 function matchQualifier(token) {
   const negated = token.startsWith("-");
@@ -282,8 +567,7 @@ function matchQualifier(token) {
   if (idx <= 0) return null;
   const key = body.slice(0, idx).toLowerCase();
   let value = body.slice(idx + 1);
-  if (value === "") return null;
-  if (!/^[a-z]+$/i.test(key)) return null;
+  if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/i.test(key)) return null;
   if (value.startsWith("//")) return null;
   if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
     value = value.slice(1, -1);
@@ -316,11 +600,143 @@ function applyFlagFilters(query, flags) {
     });
   return { ...query, qualifiers };
 }
+function withoutQualifier(query, index) {
+  const remaining = query.qualifiers.filter((_, i) => i !== index);
+  const parts = [...query.keywords];
+  for (const q of remaining) {
+    const needsQuote = q.value.includes(" ") && !q.value.startsWith('"');
+    const value = needsQuote ? `"${q.value}"` : q.value;
+    parts.push(`${q.negated ? "-" : ""}${q.key}:${value}`);
+  }
+  const text = parts.join(" ").trim();
+  return text === "" ? null : text;
+}
 function validateQuery(query) {
   const has = (key) => query.qualifiers.some((q) => q.key === key && !q.negated);
   if (has("visibility") && has("private")) {
-    throw new Error("Cannot combine `visibility:` and `private:` filters.");
+    throw new BadQueryError(
+      "Cannot combine `visibility:` and `private:` filters.",
+      `${query.qualifiers.filter((q) => q.key === "private" && !q.negated).map((q) => withoutQualifier(query, query.qualifiers.indexOf(q))).find((v) => v !== null) ?? query.raw}`
+    );
+  }
+  for (let i = 0; i < query.qualifiers.length; i++) {
+    const q = query.qualifiers[i];
+    const problem = validateQualifierValue(q.key, q.value);
+    if (problem) {
+      throw new BadQueryError(problem, withoutQualifier(query, i) ?? void 0);
+    }
+  }
+}
+var OVER_CONSTRAINT_WEIGHT = {
+  size: 100,
+  stars: 95,
+  forks: 80,
+  created: 75,
+  pushed: 70,
+  updated: 70,
+  visibility: 65,
+  repo: 60,
+  user: 55,
+  org: 50,
+  topic: 45,
+  in: 30,
+  license: 25,
+  language: 20,
+  fork: 15,
+  archived: 10
+};
+function loosenNumericBound(value) {
+  const { op, rest } = splitComparison(value.trim());
+  const count = parseCount(rest);
+  if (count === null || count === 0) return null;
+  const loosened = Math.max(1, Math.floor(count / 10));
+  return `${op || ">="}${loosened}`;
+}
+function loosenDateBound(value) {
+  const { op, rest } = splitComparison(value.trim());
+  if (!isValidISODate(rest)) return null;
+  const year = Number.parseInt(rest.slice(0, 4), 10);
+  if (!Number.isFinite(year)) return null;
+  const shifted = op === "<" || op === "<=" ? year + 2 : Math.max(1970, year - 2);
+  return { op, date: `${shifted}${rest.slice(4)}` };
+}
+function suggestRelaxations(query, limit = 3) {
+  const out = [];
+  for (let i = 0; i < query.qualifiers.length; i++) {
+    const q = query.qualifiers[i];
+    const key = q.key.toLowerCase();
+    if (q.negated) continue;
+    const weight = OVER_CONSTRAINT_WEIGHT[key] ?? 40;
+    const emit = (relaxed, qualifier) => {
+      const rest = query.qualifiers.filter((_, j) => j !== i).map((other) => {
+        const needsQuote = other.value.includes(" ") && !other.value.startsWith('"');
+        const value = needsQuote ? `"${other.value}"` : other.value;
+        return `${other.negated ? "-" : ""}${other.key}:${value}`;
+      });
+      const text = [...query.keywords, ...rest, relaxed].join(" ").trim();
+      out.push({ suggestion: text, qualifier, confidence: weight });
+    };
+    if (NUMERIC_QUALIFIERS.has(key) || key === "followers") {
+      const rangeIdx = q.value.indexOf("..");
+      if (rangeIdx > 0) {
+        const hi = parseCount(q.value.slice(rangeIdx + 2));
+        if (hi !== null) {
+          const lo = q.value.slice(0, rangeIdx);
+          emit(`${key}:${lo}..${Math.floor(hi / 10) || hi * 2}`, key);
+        }
+      } else {
+        const looser = loosenNumericBound(q.value);
+        if (looser) emit(`${key}:${looser}`, key);
+        else {
+          const dropped2 = withoutQualifier(query, i);
+          if (dropped2) {
+            out.push({
+              suggestion: dropped2,
+              qualifier: key,
+              confidence: weight - 30
+            });
+          }
+        }
+      }
+      continue;
+    }
+    if (DATE_QUALIFIERS.has(key)) {
+      const loosened = loosenDateBound(q.value);
+      if (loosened) {
+        emit(`${key}:${loosened.op || ">="}${loosened.date}`, key);
+      } else {
+        const dropped2 = withoutQualifier(query, i);
+        if (dropped2) {
+          out.push({
+            suggestion: dropped2,
+            qualifier: key,
+            confidence: weight - 30
+          });
+        }
+      }
+      continue;
+    }
+    const dropped = withoutQualifier(query, i);
+    if (dropped) {
+      out.push({
+        suggestion: dropped,
+        qualifier: key,
+        confidence: weight - 30
+      });
+    }
   }
+  const seen = /* @__PURE__ */ new Set();
+  const unique = out.filter((r) => {
+    if (seen.has(r.suggestion)) return false;
+    seen.add(r.suggestion);
+    return true;
+  });
+  unique.sort((a, b) => b.confidence - a.confidence);
+  return unique.slice(0, limit).map((r) => ({
+    ...r,
+    // Clamp so a "drop the qualifier" hint never reports a negative score.
+    confidence: Math.max(0, r.confidence)
+  }));
 }
 function buildGitHubQuery(query) {
   const parts = [];
@@ -417,6 +833,11 @@ var GitHubSearchAdapter = class {
           });
           const remainingStr = res.headers.get("x-ratelimit-remaining");
           rateLimitRemaining = remainingStr !== null ? Number(remainingStr) : void 0;
+          if (process.env.GHFIND_LOG) {
+            this.logger.debug(
+              `[github] ${res.status} remaining=${remainingStr ?? "none"} url=${redactToken(pagedUrl, token)}`
+            );
+          }
           if (res.status === 403) {
             if (remainingStr === "0" || remainingStr === null) {
               if (this.tokens.length > 0 && attempt < this.tokens.length) {
@@ -428,9 +849,25 @@ var GitHubSearchAdapter = class {
             }
             const body = await res.text().catch(() => "");
             this.logger.error(
-              `[github] non-rate-limit 403: ${body.slice(0, 200)}`
+              `[github] non-rate-limit 403: remaining=${remainingStr} retry-after=${res.headers.get("retry-after") ?? "none"} x-ratelimit-reset=${res.headers.get("x-ratelimit-reset") ?? "none"} authed=${token ? "yes" : "no"} url=${redactToken(pagedUrl, token)}`
             );
-            throw new NetworkError();
+            this.logger.error(`[github] 403 body: ${body.slice(0, 400)}`);
+            let reason = "no reason given";
+            try {
+              const parsed2 = JSON.parse(body);
+              if (typeof parsed2.message === "string" && parsed2.message) {
+                reason = parsed2.message;
+              }
+            } catch {
+            }
+            throw new ForbiddenError(reason);
+          }
+          if (res.status === 401) {
+            const body = await res.text().catch(() => "");
+            this.logger.error(
+              `[github] auth rejected (401): ${body.slice(0, 200)}`
+            );
+            throw new AuthError();
           }
           if (!res.ok) {
             const body = await res.text().catch(() => "");
@@ -467,6 +904,7 @@ var GitHubSearchAdapter = class {
           lastErr = void 0;
           break;
         } catch (err) {
+          if (err instanceof RateLimitError) throw err;
           lastErr = err;
           if (rateLimited) break;
         }
@@ -1715,7 +2153,7 @@ var cached = null;
 function getVersion() {
   if (cached) return cached;
   if (true) {
-    cached = "9.8.2";
+    cached = "9.9.0";
     return cached;
   }
   try {
@@ -1974,22 +2412,22 @@ async function runWatch(opts, onChange, onError) {
   let previous = [];
   let failCount = 0;
   let intervalId = null;
+  if (!opts.trending) {
+    validateQuery(applyFlagFilters(parseQuery(opts.query), {}));
+  }
   const tick = async () => {
     try {
       let repos;
       if (opts.trending) {
         const since = opts.query === "weekly" ? "weekly" : opts.query === "monthly" ? "monthly" : "daily";
         const trendingSearch = createTrendingSearch();
-        const response = await trendingSearch.search(
-          { keywords: [], qualifiers: [], raw: "trending" },
-          {
-            limit: opts.limit,
-            sort: opts.sort,
-            json: false,
-            verbose: false,
-            trendingSince: since
-          }
-        );
+        const response = await trendingSearch.search(trendingQuery(), {
+          limit: opts.limit,
+          sort: opts.sort,
+          json: false,
+          verbose: false,
+          trendingSince: since
+        });
         repos = response.repos;
       } else {
         const parsed = applyFlagFilters(parseQuery(opts.query), {});
@@ -2865,6 +3303,122 @@ function comparisonMarkdown(repos) {
   return [header, sep, ...rows].join("\n");
 }
 
+// src/markdown-images.ts
+var MIN_IMAGE_PIXELS = 100;
+var IMG_TAG = /<img\b[^>]*?src\s*=\s*["']([^"']+)["'][^>]*>/gi;
+var ALT_ATTR = /\balt\s*=\s*["']([^"']*)["']/i;
+var LENGTH_ATTR = /\b(width|height)\s*=\s*(?:"([^"]*)"|'([^']*)')/gi;
+var PIXEL_VALUE = /^(\d+)(?:px)?$/i;
+var HTML_TAG = /<\/?[a-z][^>]*>/gi;
+function declaredImageSize(tag) {
+  const values = {};
+  for (const [, name, dq, sq] of tag.matchAll(LENGTH_ATTR)) {
+    const raw = dq ?? sq ?? "";
+    const match = PIXEL_VALUE.exec(raw.trim());
+    if (!match) continue;
+    const n = Number.parseInt(match[1], 10);
+    if (Number.isFinite(n) && n > 0) {
+      values[name] = n;
+    }
+  }
+  if (values.width === void 0 && values.height === void 0)
+    return void 0;
+  return {
+    width: values.width ?? values.height ?? 0,
+    height: values.height ?? values.width ?? 0
+  };
+}
+function declaresTooSmall(size) {
+  if (!size) return false;
+  return size.width < MIN_IMAGE_PIXELS || size.height < MIN_IMAGE_PIXELS;
+}
+function imagesFromHtml(raw) {
+  if (!raw || !/<img\b/i.test(raw)) return [];
+  const withoutTags = raw.replace(IMG_TAG, "").replace(/<\/?(?:p|div|center|br|a|picture|source)\b[^>]*>/gi, "").trim();
+  if (withoutTags) return [];
+  const refs = [];
+  for (const match of raw.matchAll(IMG_TAG)) {
+    const tag = match[0];
+    const alt = ALT_ATTR.exec(tag)?.[1] ?? "";
+    refs.push({ href: match[1], alt, declared: declaredImageSize(tag) });
+  }
+  return refs;
+}
+function inlinePlainText(tokens) {
+  if (!tokens) return "";
+  let out = "";
+  for (const token of tokens) {
+    if (token.type === "image") continue;
+    if (token.type === "html") {
+      out += (token.raw ?? "").replace(HTML_TAG, "");
+      continue;
+    }
+    if (token.type === "br") {
+      out += "\n";
+      continue;
+    }
+    if (token.text && (!token.tokens || token.tokens.length === 0)) {
+      out += token.text;
+      continue;
+    }
+    if (token.tokens?.length) {
+      out += inlinePlainText(token.tokens);
+      continue;
+    }
+    if (token.raw) out += token.raw.replace(HTML_TAG, "");
+  }
+  return out;
+}
+function extractImageRefs(token) {
+  const images = [];
+  let linkUrl;
+  const collect = (inline2) => {
+    if (inline2.type === "image") {
+      if (inline2.href)
+        images.push({ href: inline2.href, alt: inline2.text ?? "", linkUrl });
+      return true;
+    }
+    if (inline2.type === "link" || inline2.type === "linkReference") {
+      if (inline2.tokens?.length) {
+        const outer = linkUrl;
+        linkUrl = inline2.href || outer;
+        const ok = inline2.tokens.every(collect);
+        linkUrl = outer;
+        return ok;
+      }
+      return false;
+    }
+    if (inline2.type === "html") {
+      const refs = imagesFromHtml(inline2.raw);
+      if (refs.length > 0) {
+        images.push(...refs);
+        return true;
+      }
+      return !(inline2.raw ?? "").replace(HTML_TAG, "").trim();
+    }
+    if (inline2.type === "text" || inline2.type === "escape") {
+      return !(inline2.text ?? "").trim();
+    }
+    return false;
+  };
+  if (token.type === "image" && token.href) {
+    return [{ href: token.href, alt: token.text ?? "" }];
+  }
+  if (token.type === "html") {
+    const refs = imagesFromHtml(token.raw);
+    return refs.length > 0 ? dropTooSmall(refs) : null;
+  }
+  const inline = token.tokens ?? [];
+  if (inline.length === 0) return null;
+  for (const child of inline) {
+    if (!collect(child)) return null;
+  }
+  return images.length > 0 ? dropTooSmall(images) : null;
+}
+function dropTooSmall(refs) {
+  return refs.filter((image) => !declaresTooSmall(image.declared));
+}
+
 // src/image-loader.ts
 var MAX_IMAGE_BYTES = 6 * 1024 * 1024;
 var BADGE_HOST = /(^|\.)(shields\.io|badgen\.net|badge\.fury\.io|codecov\.io|coveralls\.io|travis-ci\.(org|com)|snyk\.io|sonarcloud\.io|david-dm\.(org|io))$/i;
@@ -3032,6 +3586,23 @@ async function loadImageBytes(url, opts) {
 function readmeBaseUrl(owner, repo, branch, path = "README.md") {
   return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${path}`;
 }
+async function imageSizeFromBytes(bytes) {
+  const ImageCtor = globalThis.Bun?.Image;
+  if (!ImageCtor) return void 0;
+  try {
+    const meta = await new ImageCtor(bytes).metadata();
+    if (!meta.width || !meta.height) return void 0;
+    return { width: meta.width, height: meta.height };
+  } catch {
+    return void 0;
+  }
+}
+async function shouldRenderImage(bytes, declared) {
+  if (declared) return !declaresTooSmall(declared);
+  const measured = await imageSizeFromBytes(bytes);
+  if (!measured) return true;
+  return !declaresTooSmall(measured);
+}
 
 // src/readme.ts
 var CANDIDATES = [
@@ -3267,6 +3838,7 @@ import {
   SelectRenderable,
   ScrollBoxRenderable as ScrollBoxRenderable3
 } from "@opentui/core";
+import { appendFileSync as appendFileSync2 } from "fs";
 
 // src/trending.ts
 import {
@@ -3340,6 +3912,17 @@ function buildHelpSections() {
         { keys: "PageUp", action: "Scroll to top of results" }
       ]
     },
+    {
+      title: " Error Recovery ",
+      titleColor: "red",
+      rows: [
+        { keys: "r", action: "Retry after an error" },
+        { keys: "t", action: "Fix GitHub token (401/403)" },
+        { keys: "u", action: "Search without a token (401)" },
+        { keys: "c", action: "Change token (rate limit)" }
+      ],
+      note: "Active only while the matching error is in the status bar."
+    },
     {
       title: " Trending Mode ",
       titleColor: "yellow",
@@ -3552,9 +4135,35 @@ function touchSavedSearch(name) {
 
 // src/session.ts
 var SESSION_FILE = "session.json";
+var MAX_QUERY_LENGTH = 200;
+function sanitizeQuery(query) {
+  if (typeof query !== "string") return void 0;
+  const trimmed = query.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_QUERY_LENGTH) {
+    return void 0;
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return void 0;
+  }
+  return trimmed;
+}
+function sanitizeSession(state) {
+  if (!state || typeof state !== "object") return null;
+  const mode = state.mode === "trending" || state.mode === "packages" || state.mode === "search" ? state.mode : "search";
+  const trendingTab = typeof state.trendingTab === "string" && state.trendingTab.length > 0 ? state.trendingTab : "This Week";
+  const limit = typeof state.limit === "number" && Number.isFinite(state.limit) ? state.limit : 50;
+  const sort = typeof state.sort === "string" ? state.sort : "best-match";
+  return {
+    mode,
+    query: sanitizeQuery(state.query) ?? "",
+    sort,
+    limit,
+    trendingTab
+  };
+}
 function saveSession(state) {
   try {
-    writeJSON(SESSION_FILE, state);
+    writeJSON(SESSION_FILE, sanitizeSession(state));
   } catch (err) {
     if (process.env.DEBUG)
       console.error(
@@ -3563,7 +4172,7 @@ function saveSession(state) {
   }
 }
 function restoreSession() {
-  return readJSON(SESSION_FILE, null);
+  return sanitizeSession(readJSON(SESSION_FILE, null));
 }
 
 // src/markdown-view.ts
@@ -3869,83 +4478,6 @@ async function rasterizeImage(bytes, opts) {
   }
 }
 
-// src/markdown-images.ts
-var IMG_TAG = /<img\b[^>]*?src\s*=\s*["']([^"']+)["'][^>]*>/gi;
-var ALT_ATTR = /\balt\s*=\s*["']([^"']*)["']/i;
-var HTML_TAG = /<\/?[a-z][^>]*>/gi;
-function imagesFromHtml(raw) {
-  if (!raw || !/<img\b/i.test(raw)) return [];
-  const withoutTags = raw.replace(IMG_TAG, "").replace(/<\/?(?:p|div|center|br|a|picture|source)\b[^>]*>/gi, "").trim();
-  if (withoutTags) return [];
-  const refs = [];
-  for (const match of raw.matchAll(IMG_TAG)) {
-    const tag = match[0];
-    const alt = ALT_ATTR.exec(tag)?.[1] ?? "";
-    refs.push({ href: match[1], alt });
-  }
-  return refs;
-}
-function inlinePlainText(tokens) {
-  if (!tokens) return "";
-  let out = "";
-  for (const token of tokens) {
-    if (token.type === "image") continue;
-    if (token.type === "html") {
-      out += (token.raw ?? "").replace(HTML_TAG, "");
-      continue;
-    }
-    if (token.type === "br") {
-      out += "\n";
-      continue;
-    }
-    if (token.text && (!token.tokens || token.tokens.length === 0)) {
-      out += token.text;
-      continue;
-    }
-    if (token.tokens?.length) {
-      out += inlinePlainText(token.tokens);
-      continue;
-    }
-    if (token.raw) out += token.raw.replace(HTML_TAG, "");
-  }
-  return out;
-}
-function extractImageRefs(token) {
-  const images = [];
-  const collect = (inline2) => {
-    if (inline2.type === "image") {
-      if (inline2.href)
-        images.push({ href: inline2.href, alt: inline2.text ?? "" });
-      return true;
-    }
-    if (inline2.type === "html") {
-      const refs = imagesFromHtml(inline2.raw);
-      if (refs.length > 0) {
-        images.push(...refs);
-        return true;
-      }
-      return !(inline2.raw ?? "").replace(HTML_TAG, "").trim();
-    }
-    if (inline2.type === "text" || inline2.type === "escape") {
-      return !(inline2.text ?? "").trim();
-    }
-    return false;
-  };
-  if (token.type === "image" && token.href) {
-    return [{ href: token.href, alt: token.text ?? "" }];
-  }
-  if (token.type === "html") {
-    const refs = imagesFromHtml(token.raw);
-    return refs.length > 0 ? refs : null;
-  }
-  const inline = token.tokens ?? [];
-  if (inline.length === 0) return null;
-  for (const child of inline) {
-    if (!collect(child)) return null;
-  }
-  return images.length > 0 ? images : null;
-}
-
 // src/markdown-view.ts
 var MAX_IMAGE_ROWS = 24;
 var RASTER_CACHE_LIMIT = 32;
@@ -3981,17 +4513,19 @@ function hexToRgb(hex) {
 function rgba(color) {
   return RGBA.fromValues(color[0], color[1], color[2], 255);
 }
-function imageStyledText(image) {
+function imageStyledText(image, linkUrl) {
   const chunks = [];
   toImageRuns(image).forEach((runs, rowIndex) => {
     if (rowIndex > 0) chunks.push({ __isChunk: true, text: "\n" });
     for (const run2 of runs) {
-      chunks.push({
+      const chunk = {
         __isChunk: true,
         text: run2.text,
         fg: rgba(run2.top),
         bg: rgba(run2.bottom)
-      });
+      };
+      if (linkUrl) chunk.link = { url: linkUrl };
+      chunks.push(chunk);
     }
   });
   return new StyledText3(chunks);
@@ -4018,15 +4552,21 @@ function createMarkdownView(opts) {
     tableOptions: { style: "grid" },
     width: "100%"
   });
-  const caption = (label, color = muted()) => new TextRenderable3(renderer, {
-    content: `  ${label}`,
-    fg: color,
+  const caption = (label, linkUrl, color = muted()) => new TextRenderable3(renderer, {
+    content: new StyledText3([
+      {
+        __isChunk: true,
+        text: `  ${label}`,
+        fg: RGBA.fromHex(color),
+        ...linkUrl ? { link: { url: linkUrl } } : {}
+      }
+    ]),
     bg: bg(),
     wrapMode: "word",
     flexShrink: 0,
     width: "100%"
   });
-  const rasterize = (url) => {
+  const rasterize = (url, declared) => {
     const maxCols = Math.max(8, Math.floor(opts.getImageWidth?.() ?? 100));
     const key = `${maxCols}|${url}`;
     const cached2 = rasterCache.get(key);
@@ -4036,6 +4576,7 @@ function createMarkdownView(opts) {
       if (!loader) return null;
       const bytes = await loader(url);
       if (!bytes) return null;
+      if (!await shouldRenderImage(bytes, declared)) return null;
       return rasterizeImage(bytes, {
         maxCols,
         maxRows: maxImageRows,
@@ -4053,24 +4594,25 @@ function createMarkdownView(opts) {
   const imageNode = (image) => {
     const label = `\u{1F5BC}  ${image.alt.trim() || "image"}`;
     const url = imageBase ? resolveReadmeImageUrl(image.href, imageBase) : null;
-    if (!imagesEnabled || !url || !opts.loadImage) return caption(label);
+    if (!imagesEnabled || !url || !opts.loadImage)
+      return caption(label, image.linkUrl);
     const container = new BoxRenderable3(renderer, {
       flexDirection: "column",
       flexShrink: 0,
       width: "100%"
     });
-    const placeholder = caption(`${label}  (loading\u2026)`);
+    const placeholder = caption(`${label}  (loading\u2026)`, image.linkUrl);
     container.add(placeholder);
-    void rasterize(url).then(
+    void rasterize(url, image.declared).then(
       (cells) => {
         if (container.isDestroyed || !container.parent) return;
         container.remove(placeholder);
         placeholder.destroy();
-        container.add(caption(label));
+        container.add(caption(label, image.linkUrl));
         if (cells) {
           container.add(
             new TextRenderable3(renderer, {
-              content: imageStyledText(cells),
+              content: imageStyledText(cells, image.linkUrl),
               bg: bg(),
               wrapMode: "none",
               selectable: false,
@@ -4112,17 +4654,22 @@ function createMarkdownView(opts) {
   const buildRenderNode = () => (token, _context) => {
     if (token.type === "heading") return headingNode(token);
     const images = extractImageRefs(token);
-    if (images && images.length > 0) {
-      const box = new BoxRenderable3(renderer, {
-        flexDirection: "column",
+    if (images === null) return void 0;
+    if (images.length === 0) {
+      return new BoxRenderable3(renderer, {
         flexShrink: 0,
         width: "100%",
-        marginTop: 1
+        height: 0
       });
-      for (const image of images) box.add(imageNode(image));
-      return box;
     }
-    return void 0;
+    const box = new BoxRenderable3(renderer, {
+      flexDirection: "column",
+      flexShrink: 0,
+      width: "100%",
+      marginTop: 1
+    });
+    for (const image of images) box.add(imageNode(image));
+    return box;
   };
   renderable.renderNode = buildRenderNode();
   return {
@@ -4325,19 +4872,40 @@ function shouldCheckUpdate() {
   if (Date.now() - state.lastCheck < CHECK_INTERVAL_MS) return false;
   return true;
 }
+function semverParts(v) {
+  const core = v.trim().replace(/^v/i, "").split(/[-+]/)[0];
+  return core.split(".").map((s) => {
+    const n = Number(s);
+    return Number.isFinite(n) ? n : 0;
+  });
+}
+function isPrerelease(v) {
+  const core = v.trim().replace(/^v/i, "");
+  const plus = core.indexOf("+");
+  const coreOnly = plus === -1 ? core : core.slice(0, plus);
+  return coreOnly.includes("-");
+}
 function isNewerVersion(current, latest) {
   if (typeof Bun !== "undefined" && Bun.semver) {
     return Bun.semver.order(current, latest) < 0;
   }
-  const curParts = current.split(".").map((s) => Number(s.split("-")[0]));
-  const newParts = latest.split(".").map((s) => Number(s.split("-")[0]));
+  const curParts = semverParts(current);
+  const newParts = semverParts(latest);
+  let order = 0;
   for (let i = 0; i < Math.max(curParts.length, newParts.length); i++) {
     const c = curParts[i] ?? 0;
     const n = newParts[i] ?? 0;
-    if (n > c) return true;
-    if (n < c) return false;
+    if (n > c) {
+      order = 1;
+      break;
+    }
+    if (n < c) {
+      order = -1;
+      break;
+    }
   }
-  return false;
+  if (order !== 0) return order > 0;
+  return isPrerelease(current) && !isPrerelease(latest);
 }
 async function checkForUpdate(currentVersion) {
   if (process.env.DEBUG)
@@ -4444,6 +5012,17 @@ function recordPreUpdateState(currentVersion) {
     lastInstalledVersion: currentVersion
   });
 }
+function markPostUpgradeSeen(currentVersion) {
+  try {
+    const state = readUpdateState();
+    if (state.lastInstalledVersion === currentVersion) return;
+    if (isNewerVersion(currentVersion, state.lastInstalledVersion ?? "")) {
+      return;
+    }
+    writeUpdateState({ ...state, lastInstalledVersion: currentVersion });
+  } catch {
+  }
+}
 function fetchReleaseNotes(version) {
   try {
     const notesPath = join6(PKG_DIR2, "release-notes", `${version}.md`);
@@ -4518,16 +5097,33 @@ var colors = {
   surfaceDim: "#1a1919",
   borderAccent: "#1a1919"
 };
-var logger = {
-  debug: () => {
-  },
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: () => {
-  }
-};
+function createTuiLogger() {
+  const target = process.env.GHFIND_LOG;
+  if (!target) {
+    return { debug: () => {
+    }, info: () => {
+    }, warn: () => {
+    }, error: () => {
+    } };
+  }
+  const write = (level, msg) => {
+    try {
+      appendFileSync2(
+        target,
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${msg}
+`
+      );
+    } catch {
+    }
+  };
+  return {
+    debug: (m) => write("debug", m),
+    info: (m) => write("info", m),
+    warn: (m) => write("warn", m),
+    error: (m) => write("error", m)
+  };
+}
+var logger = createTuiLogger();
 var SORT_MODES = [
   { key: "best-match", label: "best-match" },
   { key: "stars", label: "stars" },
@@ -4572,7 +5168,7 @@ async function launchBrowser(theme_override) {
   const root = renderer.root;
   root.flexDirection = "column";
   const config = loadConfig();
-  const githubToken = config.githubToken || process.env.GITHUB_TOKEN;
+  let githubToken = config.githubToken || process.env.GITHUB_TOKEN;
   const theme = loadTheme(theme_override || config.theme);
   Object.assign(colors, theme);
   if (terminalBg) {
@@ -4755,6 +5351,10 @@ async function launchBrowser(theme_override) {
         currentMode = "search";
         showLanding(false);
         showSearchMode();
+        if (currentQueryInput) {
+          searchInput.value = currentQueryInput;
+          renderer.requestRender();
+        }
       }
     },
     {
@@ -5792,6 +6392,7 @@ async function launchBrowser(theme_override) {
     if (!state.lastInstalledVersion) return;
     if (state.lastInstalledVersion === currentVersion) return;
     const notes = fetchReleaseNotes(currentVersion);
+    markPostUpgradeSeen(currentVersion);
     updateSelectedOption = 0;
     updateHeader.content = `  Updated ghfind ${state.lastInstalledVersion} \u2192 ${currentVersion}
 `;
@@ -6079,9 +6680,85 @@ async function launchBrowser(theme_override) {
       setStatus(nextTip());
     }
   }, 2e3);
+  const tokenPromptBox = new BoxRenderable5(renderer, {
+    visible: false,
+    position: "absolute",
+    top: 0,
+    left: 0,
+    width: "100%",
+    flexDirection: "row",
+    paddingY: 1,
+    paddingLeft: 1,
+    backgroundColor: colors.surface
+  });
+  const tokenPromptLabel = new TextRenderable5(renderer, {
+    content: " GitHub token:",
+    fg: colors.accent,
+    height: 1
+  });
+  const tokenPromptInput = new InputRenderable(renderer, {
+    placeholder: "paste token, Enter to save \u2014 Esc cancels",
+    value: "",
+    backgroundColor: colors.surface,
+    textColor: colors.text,
+    flexGrow: 1
+  });
+  tokenPromptBox.add(tokenPromptLabel);
+  tokenPromptBox.add(tokenPromptInput);
+  root.add(tokenPromptBox);
+  let tokenPromptQuery = null;
+  function showTokenPrompt(query) {
+    tokenPromptQuery = query;
+    tokenPromptInput.value = "";
+    tokenPromptBox.visible = true;
+    searchBox.visible = false;
+    tokenPromptInput.focus();
+    renderer.requestRender();
+  }
+  function hideTokenPrompt() {
+    tokenPromptBox.visible = false;
+    tokenPromptQuery = null;
+    if (currentMode === "search" || currentMode === "packages") {
+      searchBox.visible = true;
+      searchInput.focus();
+    }
+    renderer.requestRender();
+  }
+  function persistToken2(token) {
+    githubToken = token;
+    config.githubToken = token;
+    saveConfig(config);
+  }
+  tokenPromptInput.on("enter", () => {
+    const token = tokenPromptInput.value.trim();
+    const query = tokenPromptQuery;
+    hideTokenPrompt();
+    if (!token || !query) return;
+    persistToken2(token);
+    setStatus("Token saved");
+    doSearch(query);
+  });
+  function fixTokenAction() {
+    showTokenPrompt(currentQueryInput || "stars:>10000");
+  }
+  function unsetTokenAction() {
+    githubToken = void 0;
+    if (config.githubToken) {
+      delete config.githubToken;
+      saveConfig(config);
+    }
+    setStatus("Token cleared \u2014 searching without one");
+    if (currentQueryInput) doSearch(currentQueryInput);
+  }
   function setStatus(msg) {
     statusMgr.set("idle", msg);
   }
+  let errorHint = null;
+  function reportError2(err) {
+    errorHint = err instanceof AuthError ? "auth" : err instanceof ForbiddenError ? "forbidden" : err instanceof RateLimitError ? "ratelimit" : err instanceof NetworkError ? "network" : null;
+    const msg = err instanceof SearchCliError ? err.userMessage : err instanceof Error ? err.message : String(err);
+    statusMgr.set("error", msg.slice(0, 60));
+  }
   function buildSessionState() {
     const mode = currentMode === "trending" ? "trending" : currentMode === "packages" ? "packages" : "search";
     return {
@@ -6298,6 +6975,7 @@ async function launchBrowser(theme_override) {
   async function loadTrending() {
     currentMode = "trending";
     isLoading = true;
+    errorHint = null;
     searchBox.visible = false;
     toolbarText.visible = false;
     trendingTabBox.visible = true;
@@ -6311,16 +6989,13 @@ async function launchBrowser(theme_override) {
     renderer.requestRender();
     try {
       const searchModule = new SearchModule(new TrendingAdapter());
-      const response = await searchModule.search(
-        { keywords: [], qualifiers: [], raw: "trending" },
-        {
-          limit: 25,
-          sort: "stars",
-          json: false,
-          verbose: false,
-          trendingSince: tabSince(trendingTab)
-        }
-      );
+      const response = await searchModule.search(trendingQuery(), {
+        limit: 25,
+        sort: "stars",
+        json: false,
+        verbose: false,
+        trendingSince: tabSince(trendingTab)
+      });
       const fetched = response.repos;
       const since = tabSince(trendingTab);
       trendingPeriod = since === "daily" ? "today" : since === "weekly" ? "this week" : "this month";
@@ -6347,11 +7022,10 @@ async function launchBrowser(theme_override) {
         resultCount: fetched.length
       });
     } catch (err) {
-      const msg = err instanceof SearchCliError ? err.userMessage : err instanceof Error ? err.message : String(err);
       resultsSelect.options = [
         { name: " (error)", description: "", value: null }
       ];
-      statusMgr.set("error", msg.slice(0, 60));
+      reportError2(err);
     }
     isLoading = false;
     renderer.requestRender();
@@ -6390,6 +7064,7 @@ async function launchBrowser(theme_override) {
     if (q === "" || isLoading) return;
     currentQueryInput = q;
     isLoading = true;
+    errorHint = null;
     resultsSelect.options = [
       { name: "  Searching packages...", description: "", value: null }
     ];
@@ -6427,6 +7102,7 @@ async function launchBrowser(theme_override) {
   async function doSearch(queryText, append = false) {
     const q = queryText.trim();
     if (q === "" || isLoading) return;
+    errorHint = null;
     if (!append) currentPage = 1;
     deepDiveActive = false;
     isLoading = true;
@@ -6459,7 +7135,10 @@ async function launchBrowser(theme_override) {
         currentRepos = newRepos;
       }
       if (currentRepos.length === 0) {
-        throw new NoResultsError(q);
+        throw new NoResultsError(
+          q,
+          suggestRelaxations(parsed).map((r) => r.suggestion)
+        );
       } else {
         resultsSelect.options = currentRepos.map((r) => ({
           name: formatResultLine(r),
@@ -6489,8 +7168,7 @@ async function launchBrowser(theme_override) {
           { name: " (error)", description: "", value: null }
         ];
       }
-      const msg = err instanceof SearchCliError ? err.userMessage : err instanceof Error ? err.message : String(err);
-      statusMgr.set("error", msg.slice(0, 60));
+      reportError2(err);
     }
     isLoading = false;
     renderer.requestRender();
@@ -6587,6 +7265,16 @@ ${pack.description ?? ""}`;
     }
   });
   renderer.keyInput.on("keypress", (key) => {
+    if (tokenPromptBox.visible) {
+      if (key.name === "escape") {
+        hideTokenPrompt();
+        setStatus("Token entry cancelled");
+        renderer.requestRender();
+        return;
+      }
+      if (key.name === "enter" || key.name === "return") return;
+      return;
+    }
     if (currentOverlay !== "none") {
       if (key.name === "escape") {
         if (currentOverlay === "leader") {
@@ -6890,6 +7578,27 @@ ${pack.description ?? ""}`;
       showLeaderMenu();
       return;
     }
+    if (!searchInput.focused && errorHint) {
+      if (key.name === "r") {
+        errorHint = null;
+        if (currentMode === "trending") loadTrending();
+        else if (currentQueryInput) doSearch(currentQueryInput);
+        renderer.requestRender();
+        return;
+      }
+      if (key.name === "t" && (errorHint === "auth" || errorHint === "forbidden")) {
+        fixTokenAction();
+        return;
+      }
+      if (key.name === "u" && errorHint === "auth") {
+        unsetTokenAction();
+        return;
+      }
+      if (key.name === "c" && errorHint === "ratelimit") {
+        fixTokenAction();
+        return;
+      }
+    }
     if (key.name === "t" && !searchInput.focused) {
       const current = config.theme;
       const themes = listThemes();
@@ -6984,25 +7693,10 @@ ${pack.description ?? ""}`;
     }
   });
   const _currentVersion = getVersion();
-  if (!session?.mode) {
-    showLanding(true);
-  }
+  showLanding(true);
   checkForUpdateAndShow();
   checkPostUpgradePanel();
   renderer.start();
-  if (session?.mode) {
-    if (currentMode === "trending") {
-      loadTrending();
-    } else {
-      searchInput.value = currentQueryInput;
-      if (currentQueryInput) {
-        doSearch(currentQueryInput);
-      } else {
-        showSearchMode();
-      }
-      searchInput.focus();
-    }
-  }
   renderer.requestRender();
 }
 function formatResultLine(repo) {
@@ -7436,7 +8130,7 @@ function formatPackageLines(pkgs) {
 function asMcpToolError(err) {
   return new McpToolError(err instanceof Error ? err.message : String(err));
 }
-var TRENDING_QUERY = { keywords: [], qualifiers: [], raw: "trending" };
+var TRENDING_QUERY = trendingQuery();
 var REPO_SORTS = ["best-match", "stars", "updated", "forks"];
 var SKILL_SOURCES = ["local", "registry"];
 var TRENDING_SINCE = ["daily", "weekly", "monthly"];
@@ -7483,6 +8177,17 @@ var TOOLS = [
       const token = resolveToken(state, args.token);
       const provider = createGitHubSearch(void 0, token ? [token] : []);
       const parsed = parseQuery(query);
+      try {
+        validateQuery(parsed);
+      } catch (err) {
+        if (err instanceof BadQueryError) {
+          return {
+            text: `Invalid query: ${err.detail}${err.hint ? ` Try: ${err.hint}` : ""}`,
+            data: { totalCount: 0, repos: [], invalidQuery: true }
+          };
+        }
+        throw err;
+      }
       const options = {
         limit,
         sort,
@@ -7490,7 +8195,18 @@ var TOOLS = [
         verbose: false,
         token
       };
-      const response = await provider.search(parsed, options);
+      let response;
+      try {
+        response = await provider.search(parsed, options);
+      } catch (err) {
+        if (err instanceof RateLimitError) {
+          return {
+            text: `GitHub API rate limit exceeded for "${query}". Set a token (GITHUB_TOKEN or the tool's token argument) to raise the limit from 60/hr to 5,000/hr.`,
+            data: { totalCount: 0, repos: [], rateLimited: true }
+          };
+        }
+        throw err;
+      }
       const repos = rankRepos(response.repos, sort);
       try {
         appendHistory({
@@ -8429,6 +9145,7 @@ Options:
 }
 function buildSearchContext(flags) {
   const parsed = applyFlagFilters(parseQuery(flags.query), {});
+  validateQuery(parsed);
   return {
     query: flags.query,
     parsed,
@@ -8860,17 +9577,14 @@ async function runNonInteractive(flags, outputFormat) {
         console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
       }
-      const response = await trendingSearch.search(
-        { keywords: [], qualifiers: [], raw: "trending" },
-        {
-          limit: 25,
-          sort: "stars",
-          json: false,
-          verbose: false,
-          trendingSince: since,
-          ...language ? { trendingLanguage: language } : {}
-        }
-      );
+      const response = await trendingSearch.search(trendingQuery(), {
+        limit: 25,
+        sort: "stars",
+        json: false,
+        verbose: false,
+        trendingSince: since,
+        ...language ? { trendingLanguage: language } : {}
+      });
       if (outputFormat) {
         console.log(format(response.repos, outputFormat));
       } else if (flags.count) {