github-search-cli 0.8.2 → 9.1.0

package/dist/cli.js

@@ -0,0 +1,3761 @@
+#!/usr/bin/env node
+import {
+  loadConfig,
+  saveConfig,
+  stateDir
+} from "./chunk-TUMYR2IC.js";
+
+// src/errors.ts
+var SearchCliError = class extends Error {
+  constructor(message, userMessage, recoverable = true) {
+    super(message);
+    this.userMessage = userMessage;
+    this.recoverable = recoverable;
+    this.name = "SearchCliError";
+  }
+  userMessage;
+  recoverable;
+};
+var NetworkError = class extends SearchCliError {
+  constructor() {
+    super(
+      "Network request failed",
+      "\u26A0 Network error \u2014 check your connection. Retrying in 5s... [r]etry now"
+    );
+    this.name = "NetworkError";
+  }
+};
+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";
+    super(msg, msg);
+    this.hasToken = hasToken;
+    this.name = "RateLimitError";
+  }
+  hasToken;
+};
+var NoResultsError = class extends SearchCliError {
+  constructor(query) {
+    super(
+      `No results for "${query}"`,
+      `\u{1F50D} No results for "${query}". Tips: check spelling, try fewer qualifiers, or [b]rowse trending`
+    );
+    this.query = query;
+    this.name = "NoResultsError";
+  }
+  query;
+};
+var ParseError = class extends SearchCliError {
+  constructor(source, detail) {
+    super(
+      `Parse error from ${source}: ${detail}`,
+      `\u26A0 Could not parse ${source}. GitHub may have changed the layout. [r]etry`
+    );
+    this.name = "ParseError";
+  }
+};
+
+// src/search.ts
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var MemoryCache = class {
+  constructor(defaultTtlMs = 3e5) {
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  defaultTtlMs;
+  cache = /* @__PURE__ */ new Map();
+  static key(...parts) {
+    return parts.join("::").toLowerCase().replace(/\s+/g, " ");
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() - entry.cachedAt > entry.ttlMs) {
+      this.cache.delete(key);
+      return null;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return entry.data;
+  }
+  set(key, data, ttlMs) {
+    if (this.cache.size >= MAX_CACHE_SIZE) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) this.cache.delete(firstKey);
+    }
+    this.cache.set(key, {
+      data,
+      cachedAt: Date.now(),
+      ttlMs: ttlMs ?? this.defaultTtlMs
+    });
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+var MAX_CACHE_SIZE = 50;
+function normalizeRepo(item) {
+  const owner = item.owner?.login ?? item.full_name?.split("/")[0] ?? "";
+  return {
+    id: item.id ?? 0,
+    fullName: item.full_name ?? "",
+    name: item.name ?? "",
+    owner,
+    description: item.description ?? null,
+    url: item.html_url ?? "",
+    stars: item.stargazers_count ?? 0,
+    forks: item.forks_count ?? 0,
+    watchers: item.watchers_count ?? 0,
+    language: item.language ?? null,
+    topics: item.topics ?? [],
+    archived: item.archived ?? false,
+    isFork: item.fork ?? false,
+    private: item.private ?? false,
+    createdAt: item.created_at ?? "",
+    updatedAt: item.updated_at ?? "",
+    pushedAt: item.pushed_at ?? "",
+    score: item.score ?? 0
+  };
+}
+function normalizeEnvelope(env) {
+  return (env.items ?? []).map(normalizeRepo);
+}
+var KNOWN_QUALIFIERS = [
+  "language",
+  "stars",
+  "fork",
+  "archived",
+  "topic",
+  "user",
+  "org",
+  "repo",
+  "updated",
+  "pushed",
+  "visibility",
+  "in",
+  "size",
+  "license",
+  "created"
+];
+var QUALIFIER_SUGGESTIONS = {
+  l: ["language:"],
+  s: ["stars:", "size:"],
+  t: ["topic:"],
+  u: ["user:"],
+  o: ["org:"],
+  r: ["repo:"],
+  c: ["created:"],
+  p: ["pushed:"],
+  v: ["visibility:"],
+  i: ["in:"],
+  f: ["fork:"],
+  a: ["archived:"]
+};
+function suggestFor(input) {
+  const trimmed = input.trim().toLowerCase();
+  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 + ":");
+}
+function tokenize(input) {
+  const tokens = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === '"') {
+      inQuotes = !inQuotes;
+      current += ch;
+    } else if (/\s/.test(ch) && !inQuotes) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) {
+    if (current.startsWith('"') && current.endsWith('"') && current.length >= 2) {
+      current = current.slice(1, -1);
+    }
+    tokens.push(current);
+  }
+  return tokens;
+}
+function parseQuery(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    return { keywords: [], qualifiers: [], raw };
+  }
+  const keywords = [];
+  const qualifiers = [];
+  for (const token of tokenize(trimmed)) {
+    const qualifier = matchQualifier(token);
+    if (qualifier) {
+      qualifiers.push(qualifier);
+    } else {
+      keywords.push(token);
+    }
+  }
+  return { keywords, qualifiers, raw: trimmed };
+}
+function matchQualifier(token) {
+  const negated = token.startsWith("-");
+  const body = negated ? token.slice(1) : token;
+  const idx = body.indexOf(":");
+  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 (value.startsWith("//")) return null;
+  if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+    value = value.slice(1, -1);
+  }
+  return { key, value, negated };
+}
+function applyFlagFilters(query, flags) {
+  const qualifiers = [...query.qualifiers];
+  if (flags.language) qualifiers.push({ key: "language", value: flags.language, negated: false });
+  if (flags.stars) qualifiers.push({ key: "stars", value: flags.stars, negated: false });
+  if (flags.org) qualifiers.push({ key: "org", value: flags.org, negated: false });
+  if (flags.user) qualifiers.push({ key: "user", value: flags.user, negated: false });
+  if (flags.topic) qualifiers.push({ key: "topic", value: flags.topic, negated: false });
+  if (flags.archived !== void 0)
+    qualifiers.push({ key: "archived", value: flags.archived ? "true" : "false", negated: false });
+  if (flags.fork !== void 0)
+    qualifiers.push({ key: "fork", value: flags.fork ? "true" : "false", negated: false });
+  return { ...query, qualifiers };
+}
+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.");
+  }
+}
+function buildGitHubQuery(query) {
+  const parts = [];
+  for (const kw of query.keywords) {
+    const alreadyQuoted = kw.startsWith('"') && kw.endsWith('"');
+    parts.push(kw.includes(" ") && !alreadyQuoted ? `"${kw}"` : kw);
+  }
+  for (const q of query.qualifiers) {
+    const needsQuote = q.value.includes(" ") && !q.value.startsWith('"');
+    const value = needsQuote ? `"${q.value}"` : q.value;
+    parts.push(`${q.negated ? "-" : ""}${q.key}:${value}`);
+  }
+  return parts.join(" ");
+}
+function githubSortParam(sort) {
+  switch (sort) {
+    case "stars":
+      return { sort: "stars", order: "desc" };
+    case "forks":
+      return { sort: "forks", order: "desc" };
+    case "updated":
+      return { sort: "updated", order: "desc" };
+    case "best-match":
+    default:
+      return {};
+  }
+}
+function buildSearchUrl(query, options) {
+  const q = buildGitHubQuery(query);
+  const { sort, order } = githubSortParam(options.sort);
+  const params = new URLSearchParams({ q: q || " " });
+  if (sort) params.set("sort", sort);
+  if (order) params.set("order", order);
+  return `https://api.github.com/search/repositories?${params.toString()}`;
+}
+function rankRepos(repos, strategy) {
+  const copy = [...repos];
+  switch (strategy) {
+    case "stars":
+      copy.sort(byKey((r) => r.stars));
+      break;
+    case "forks":
+      copy.sort(byKey((r) => r.forks));
+      break;
+    case "updated":
+      copy.sort(byKey((r) => Date.parse(r.updatedAt)));
+      break;
+    case "best-match":
+    default:
+      break;
+  }
+  return copy;
+}
+function byKey(key) {
+  return (a, b) => key(b) - key(a) || b.stars - a.stars || a.id - b.id;
+}
+var GitHubSearchAdapter = class {
+  name = "github";
+  logger;
+  tokens;
+  tokenIndex = 0;
+  constructor(logger2 = noopLogger, tokens = []) {
+    this.logger = logger2;
+    this.tokens = tokens.filter(Boolean);
+  }
+  nextToken() {
+    if (this.tokens.length === 0) return void 0;
+    const token = this.tokens[this.tokenIndex % this.tokens.length];
+    this.tokenIndex++;
+    return token;
+  }
+  async search(query, options) {
+    const url = buildSearchUrl(query, options);
+    this.logger.debug(`[github] outgoing query: ${query.raw}`);
+    this.logger.debug(`[github] request url: ${url}`);
+    const all = [];
+    let totalCount = 0;
+    let rateLimited = false;
+    let rateLimitRemaining;
+    const perPage = Math.min(Math.max(options.limit, 1), 100);
+    const startPage = options.page ?? 1;
+    const maxPages = startPage > 1 ? startPage : Math.ceil(options.limit / perPage);
+    for (let page = startPage > 1 ? startPage : 1; page <= maxPages; page++) {
+      const pagedUrl = appendPage(url, page, perPage);
+      let lastErr;
+      for (let attempt = 0; attempt <= this.tokens.length; attempt++) {
+        const token = this.tokens.length > 0 ? this.nextToken() : options.token;
+        try {
+          const res = await fetch(pagedUrl, {
+            headers: {
+              Accept: "application/vnd.github+json",
+              "X-GitHub-Api-Version": "2022-11-28",
+              "User-Agent": "ghfind",
+              ...token ? { Authorization: `Bearer ${token}` } : {}
+            }
+          });
+          const remainingStr = res.headers.get("x-ratelimit-remaining");
+          rateLimitRemaining = remainingStr !== null ? Number(remainingStr) : void 0;
+          if (res.status === 403) {
+            if (remainingStr === "0" || remainingStr === null) {
+              if (this.tokens.length > 0 && attempt < this.tokens.length) {
+                continue;
+              }
+              this.logger.warn("[github] rate limit exceeded");
+              rateLimited = true;
+              throw new RateLimitError(!!token);
+            }
+            const body = await res.text().catch(() => "");
+            this.logger.error(`[github] non-rate-limit 403: ${body.slice(0, 200)}`);
+            throw new NetworkError();
+          }
+          if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            this.logger.error(`[github] API error ${res.status}: ${body.slice(0, 200)}`);
+            throw new NetworkError();
+          }
+          const raw = await res.text();
+          let parsed;
+          try {
+            parsed = JSON.parse(raw);
+          } catch {
+            const snippet = raw.slice(0, 200);
+            this.logger.error(`[github] invalid JSON response: ${snippet}`);
+            throw new ParseError("GitHub API", snippet.includes("<!DOCTYPE") ? "GitHub returned an HTML page (maintenance or CAPTCHA?)" : "Invalid JSON response");
+          }
+          if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.items)) {
+            this.logger.error(`[github] unexpected response shape: ${JSON.stringify(parsed).slice(0, 200)}`);
+            throw new ParseError("GitHub API", "Unexpected response shape \u2014 missing items array");
+          }
+          const env = parsed;
+          totalCount = env.total_count;
+          const repos2 = normalizeEnvelope(env);
+          all.push(...repos2);
+          lastErr = void 0;
+          break;
+        } catch (err) {
+          lastErr = err;
+          if (rateLimited) break;
+        }
+      }
+      if (lastErr && !rateLimited) throw lastErr;
+      if (rateLimited) break;
+      if (all.length >= options.limit) break;
+    }
+    const repos = all.slice(0, options.limit);
+    if (repos.length === 0) {
+      this.logger.debug("[github] empty results");
+    }
+    return { totalCount, repos, rateLimited, rateLimitRemaining };
+  }
+};
+function appendPage(url, page, perPage) {
+  const u = new URL(url);
+  u.searchParams.set("page", String(page));
+  u.searchParams.set("per_page", String(perPage));
+  return u.toString();
+}
+var TRENDING_URL = "https://github.com/trending";
+function parseTrendingHtml(html) {
+  const flat = html.replace(/>\s+</g, "><").replace(/\s+/g, " ");
+  const repos = [];
+  const articleRe = /<article class="Box-row">(.*?)<\/article>/gi;
+  let match;
+  let rank = 0;
+  while ((match = articleRe.exec(flat)) !== null) {
+    rank++;
+    const block = match[1];
+    const repoMatch = block.match(/href="\/([^\/\"]+)\/([^\"?#]+)"[^>]*class="Link"/);
+    if (!repoMatch) continue;
+    const owner = repoMatch[1];
+    const name = repoMatch[2];
+    const starsMatch = block.match(/href="\/[^\/\"]+\/[^\/\"]+\/stargazers"[^>]*>.*?<\/svg>\s*(\d[\d,]*)/);
+    const stars = starsMatch ? parseInt(starsMatch[1].replace(/,/g, ""), 10) : 0;
+    const growthMatch = block.match(/(\d[\d,]*)\s+stars\s+(today|this\s+\w+)/);
+    const starsToday = growthMatch ? parseInt(growthMatch[1].replace(/,/g, ""), 10) : 0;
+    const langMatch = block.match(/itemprop="programmingLanguage">([^<]+)</);
+    const language = langMatch ? langMatch[1].trim() : "";
+    const descMatch = block.match(/<p[^>]*class="[^"]*color-fg-muted[^"]*"[^>]*>([^<]+)</);
+    const description = descMatch ? descMatch[1].trim() : "";
+    repos.push({ rank, owner, name, stars, starsToday, language, description });
+  }
+  return repos;
+}
+function trendingRepoToRepo(r) {
+  return {
+    id: 0,
+    fullName: `${r.owner}/${r.name}`,
+    name: r.name,
+    owner: r.owner,
+    description: r.description,
+    url: `https://github.com/${r.owner}/${r.name}`,
+    stars: r.stars,
+    forks: 0,
+    watchers: 0,
+    language: r.language,
+    topics: [],
+    archived: false,
+    isFork: false,
+    private: false,
+    createdAt: "",
+    updatedAt: "",
+    pushedAt: "",
+    score: r.starsToday
+  };
+}
+var TrendingAdapter = class {
+  name = "trending";
+  logger;
+  constructor(logger2 = noopLogger) {
+    this.logger = logger2;
+  }
+  async search(_query, options) {
+    const since = options.trendingSince ?? "daily";
+    const url = since === "daily" ? TRENDING_URL : `${TRENDING_URL}?since=${since}`;
+    let res;
+    try {
+      res = await fetch(url, { headers: { "User-Agent": "ghfind" } });
+    } catch {
+      throw new NetworkError();
+    }
+    if (!res.ok) throw new NetworkError();
+    const html = await res.text();
+    const repos = parseTrendingHtml(html).map(trendingRepoToRepo);
+    return { totalCount: repos.length, repos, rateLimited: false };
+  }
+};
+var SearchModule = class _SearchModule {
+  name = "search";
+  adapter;
+  logger;
+  /** Shared cache across instances. */
+  static cache = new MemoryCache(3e5);
+  constructor(adapter, logger2 = noopLogger) {
+    this.adapter = adapter;
+    this.logger = logger2;
+  }
+  async search(query, options) {
+    const cacheKey = MemoryCache.key(
+      query.raw,
+      options.sort,
+      String(options.limit),
+      String(options.page ?? 1)
+    );
+    const cached = _SearchModule.cache.get(cacheKey);
+    if (cached) {
+      this.logger.debug("[search] cache hit");
+      return cached;
+    }
+    this.logger.debug("[search] cache miss");
+    const response = await this.adapter.search(query, options);
+    if (!response.rateLimited) {
+      _SearchModule.cache.set(cacheKey, response);
+    }
+    return response;
+  }
+};
+function createGitHubSearch(logger2 = noopLogger, tokens = []) {
+  return new SearchModule(new GitHubSearchAdapter(logger2, tokens), logger2);
+}
+function createTrendingSearch(logger2 = noopLogger) {
+  return new SearchModule(new TrendingAdapter(logger2), logger2);
+}
+
+// src/output.ts
+import { writeFileSync } from "fs";
+
+// src/open-url.ts
+function openUrl(url) {
+  try {
+    const p = process.platform;
+    if (p === "win32") Bun.spawn(["cmd", "/c", "start", "", url]);
+    else if (p === "darwin") Bun.spawn(["open", url]);
+    else Bun.spawn(["xdg-open", url]);
+  } catch {
+  }
+}
+
+// src/output.ts
+var FORMATS = /* @__PURE__ */ new Map([
+  // Export formats
+  ["json", formatJson],
+  ["csv", formatCsv],
+  ["markdown", formatMarkdown],
+  ["text", formatText],
+  // Pipe formats
+  ["urls", formatUrls],
+  ["names", formatNames],
+  ["ssh-urls", formatSshUrls],
+  ["clone-commands", formatCloneCommands],
+  ["ids", formatIds]
+]);
+function formatJson(repos) {
+  return JSON.stringify(repos, null, 2);
+}
+function csvEscape(val) {
+  const str = String(val ?? "");
+  if (str.includes('"') || str.includes(",") || str.includes("\n")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function formatCsv(repos) {
+  const header = "rank,full_name,stars,forks,language,url";
+  const rows = repos.map(
+    (r, i) => `${i + 1},${csvEscape(r.fullName)},${r.stars},${r.forks},${csvEscape(r.language ?? "")},${csvEscape(r.url)}`
+  );
+  return [header, ...rows].join("\n");
+}
+function formatMarkdown(repos) {
+  const header = "| # | Repo | Stars | Forks | Language |";
+  const sep = "|---|------|-------|-------|----------|";
+  const rows = repos.map(
+    (r, i) => `| ${i + 1} | [${r.fullName}](${r.url}) | ${r.stars.toLocaleString()} | ${r.forks.toLocaleString()} | ${r.language ?? "\u2014"} |`
+  );
+  return [header, sep, ...rows].join("\n");
+}
+function formatText(repos) {
+  return repos.map((r, i) => `${i + 1}. ${r.fullName} \u2605 ${r.stars.toLocaleString()} ${r.url}`).join("\n");
+}
+function formatUrls(repos) {
+  return repos.map((r) => r.url).join("\n");
+}
+function formatNames(repos) {
+  return repos.map((r) => r.fullName).join("\n");
+}
+function formatSshUrls(repos) {
+  return repos.map((r) => `git@github.com:${r.fullName}.git`).join("\n");
+}
+function formatCloneCommands(repos) {
+  return repos.map((r) => `git clone git@github.com:${r.fullName}.git`).join("\n");
+}
+function formatIds(repos) {
+  return repos.map((r) => String(r.id)).join("\n");
+}
+function format(repos, format2) {
+  const fn = FORMATS.get(format2);
+  if (!fn) throw new Error(`Unknown format: ${format2}`);
+  return fn(repos);
+}
+function exportToFile(repos, fmt) {
+  const ext = fmt === "markdown" ? "md" : fmt;
+  const ts = Date.now();
+  const path = `./ghfind-export-${ts}.${ext}`;
+  writeFileSync(path, format(repos, fmt), "utf-8");
+  return path;
+}
+async function pipeExec(repos, target) {
+  for (const repo of repos) {
+    const url = repo.url;
+    switch (target) {
+      case "open":
+        await openUrl(url);
+        break;
+      case "clone":
+        console.log(`git clone git@github.com:${repo.fullName}.git`);
+        break;
+    }
+  }
+}
+
+// src/watch.ts
+var MAX_FAILS = 5;
+async function runWatch(opts, onChange, onError) {
+  let previous = [];
+  let failCount = 0;
+  let intervalId = null;
+  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 }
+        );
+        repos = response.repos;
+      } else {
+        const parsed = applyFlagFilters(parseQuery(opts.query), {});
+        const provider = createGitHubSearch(void 0, opts.token ? [opts.token] : []);
+        const options = {
+          limit: opts.limit,
+          sort: opts.sort,
+          json: false,
+          verbose: false,
+          token: opts.token
+        };
+        const response = await provider.search(parsed, options);
+        repos = rankRepos(response.repos, options.sort);
+      }
+      failCount = 0;
+      const delta = previous.length > 0 ? repos.length - previous.length : 0;
+      previous = repos;
+      onChange(repos, delta);
+    } catch (err) {
+      failCount++;
+      onError(err instanceof Error ? err : new Error(String(err)));
+      if (failCount >= MAX_FAILS) {
+        onError(new Error(`Watch stopped after ${MAX_FAILS} consecutive failures`));
+        if (intervalId) clearInterval(intervalId);
+      }
+    }
+  };
+  await tick();
+  if (failCount < MAX_FAILS) {
+    intervalId = setInterval(tick, opts.intervalMs);
+  }
+}
+
+// src/init.ts
+import { createInterface } from "readline";
+
+// src/themes.ts
+var THEMES = {
+  "premium-dark": {
+    name: "premium-dark",
+    bg: "#3D3B3B",
+    surface: "#4a4848",
+    surfaceAlt: "#525050",
+    text: "#e0e4f0",
+    muted: "#a8a6a6",
+    blue: "#89b4fa",
+    green: "#a6e3a1",
+    yellow: "#f9e2af",
+    red: "#f38ba8",
+    teal: "#94e2d5",
+    purple: "#cba6f7",
+    orange: "#fab387",
+    border: "#1C1C1C",
+    borderAlt: "#2a2a2a",
+    separator: "#1C1C1C",
+    selectionBg: "#2A2A9C",
+    selectionText: "#ffffff",
+    success: "#a6e3a1",
+    warning: "#f9e2af",
+    error: "#f38ba8"
+  },
+  "tokyo-night": {
+    name: "tokyo-night",
+    bg: "#3D3B3B",
+    surface: "#4a4848",
+    surfaceAlt: "#525050",
+    text: "#e0e4f0",
+    muted: "#a8a6a6",
+    blue: "#89b4fa",
+    green: "#a6e3a1",
+    yellow: "#f9e2af",
+    red: "#f38ba8",
+    teal: "#94e2d5",
+    purple: "#cba6f7",
+    orange: "#fab387",
+    border: "#1C1C1C",
+    borderAlt: "#2a2a2a",
+    separator: "#1C1C1C",
+    selectionBg: "#2A2A9C",
+    selectionText: "#ffffff",
+    success: "#a6e3a1",
+    warning: "#f9e2af",
+    error: "#f38ba8"
+  },
+  dracula: {
+    name: "dracula",
+    bg: "#3D3B3B",
+    surface: "#4a4848",
+    surfaceAlt: "#525050",
+    text: "#f8f8f2",
+    muted: "#a8a6a6",
+    blue: "#8be9fd",
+    green: "#50fa7b",
+    yellow: "#f1fa8c",
+    red: "#ff5555",
+    teal: "#50fa7b",
+    purple: "#bd93f9",
+    orange: "#ffb86c",
+    border: "#1C1C1C",
+    borderAlt: "#2a2a2a",
+    separator: "#1C1C1C",
+    selectionBg: "#2A2A9C",
+    selectionText: "#ffffff",
+    success: "#50fa7b",
+    warning: "#f1fa8c",
+    error: "#ff5555"
+  },
+  monokai: {
+    name: "monokai",
+    bg: "#3D3B3B",
+    surface: "#4a4848",
+    surfaceAlt: "#525050",
+    text: "#f8f8f2",
+    muted: "#a8a6a6",
+    blue: "#66d9ef",
+    green: "#a6e22e",
+    yellow: "#e6db74",
+    red: "#f92672",
+    teal: "#a6e22e",
+    purple: "#ae81ff",
+    orange: "#fd971f",
+    border: "#1C1C1C",
+    borderAlt: "#2a2a2a",
+    separator: "#1C1C1C",
+    selectionBg: "#2A2A9C",
+    selectionText: "#f8f8f2",
+    success: "#a6e22e",
+    warning: "#e6db74",
+    error: "#f92672"
+  }
+};
+function loadTheme(name) {
+  return THEMES[name] ?? THEMES["tokyo-night"];
+}
+function listThemes() {
+  return Object.keys(THEMES);
+}
+
+// src/init.ts
+function ask(query) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(query, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function runInitWizard() {
+  console.log("");
+  console.log("  ghfind setup wizard");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("");
+  const token = await ask("  GitHub token (optional, press Enter to skip): ");
+  if (token && !token.startsWith("ghp_") && !token.startsWith("github_pat_") && !token.startsWith("gho_")) {
+    console.log("  \u26A0 Token doesn't look like a GitHub token (should start with ghp_, gho_, or github_pat_)");
+  }
+  const sortStr = await ask("  Default sort [best-match/stars/updated/forks] (best-match): ");
+  const limitStr = await ask("  Default result limit [10-100] (50): ");
+  const themes = listThemes();
+  const themeStr = await ask(`  Theme [${themes.join("/")}] (tokyo-night): `);
+  const config = {
+    defaultSort: ["best-match", "stars", "updated", "forks"].includes(sortStr) ? sortStr : "best-match",
+    defaultLimit: Math.min(100, Math.max(10, parseInt(limitStr) || 50)),
+    theme: themes.includes(themeStr) ? themeStr : "tokyo-night",
+    cacheTtlSeconds: 300,
+    defaultTab: "search"
+  };
+  if (token) config.githubToken = token;
+  saveConfig(config);
+  const { configPath } = await import("./config-DFL44OVL.js");
+  console.log(`  \u2713 Config saved to ${configPath()}`);
+  console.log("  Run 'ghfind' to start browsing!");
+  console.log("");
+}
+
+// src/cli.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/tui.ts
+import {
+  createCliRenderer as createCliRenderer2,
+  BoxRenderable as BoxRenderable2,
+  TextRenderable as TextRenderable2,
+  InputRenderable,
+  SelectRenderable,
+  ScrollBoxRenderable as ScrollBoxRenderable2
+} from "@opentui/core";
+
+// src/trending.ts
+import {
+  createCliRenderer,
+  BoxRenderable,
+  TextRenderable,
+  ScrollBoxRenderable,
+  StyledText,
+  bold,
+  fg,
+  dim,
+  t
+} from "@opentui/core";
+var TAB_NAMES = ["Today", "This Week", "This Month"];
+function tabSince(tab) {
+  switch (tab) {
+    case "Today":
+      return "daily";
+    case "This Week":
+      return "weekly";
+    default:
+      return "monthly";
+  }
+}
+function fmtStars(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1).replace(/\.0$/, "")}M`;
+  if (n >= 999500) return "1M";
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1).replace(/\.0$/, "")}k`;
+  return String(n);
+}
+if (import.meta.main && false) {
+  launchTrending();
+}
+
+// src/help.ts
+function buildHelpSections() {
+  return [
+    {
+      title: " Navigation ",
+      titleColor: "blue",
+      rows: [
+        { keys: "\u2191 \u2193 / j k", action: "Move selection" },
+        { keys: "Enter", action: "Open repo in browser" },
+        { keys: "/", action: "Focus search input" },
+        { keys: "Space", action: "Open command menu" },
+        { keys: "? / Ctrl+H", action: "Toggle this help screen" },
+        { keys: "q", action: "Quit" }
+      ]
+    },
+    {
+      title: " Main View ",
+      titleColor: "green",
+      rows: [
+        { keys: "Tab", action: "Auto-complete qualifier" },
+        { keys: "PageDown", action: "Next page of results" },
+        { keys: "PageUp", action: "Scroll to top of results" }
+      ]
+    },
+    {
+      title: " Trending Mode ",
+      titleColor: "yellow",
+      rows: [
+        { keys: "1-5", action: "Switch tab: Today \u2192 Week \u2192 Month \u2192 \u2026" },
+        { keys: "\u2190 \u2192 / h l", action: "Navigate tabs" }
+      ]
+    },
+    {
+      title: " Command Menu (Space)",
+      titleColor: "purple",
+      rows: [
+        { keys: "Sort", action: "Cycle sort: best-match \u2192 stars \u2192 \u2026" },
+        { keys: "Limit", action: "Cycle limit: 10 \u2192 25 \u2192 50 \u2192 100" },
+        { keys: "Refresh", action: "Re-run current search" },
+        { keys: "Graph", action: "Toggle commit activity chart" },
+        { keys: "Readme", action: "Full README viewer" },
+        { keys: "Deep-dive", action: "Languages + contributors + excerpt" },
+        { keys: "Bookmark", action: "Save / unsave selected repo" },
+        { keys: "Compare", action: "Add to / remove from comparison" },
+        { keys: "Trending", action: "Switch to trending browser" }
+      ],
+      note: "Also: Open, History, Export, Share, Topics, Saved, Notifs, Help"
+    },
+    {
+      title: " Overlay Keys ",
+      titleColor: "teal",
+      rows: [
+        { keys: "Esc / q", action: "Close any overlay" },
+        { keys: "Enter", action: "Confirm selection / run action" },
+        { keys: "d", action: "Delete entry (history, bookmarks, saved)" },
+        { keys: "\u2191 \u2193 / j k", action: "Navigate overlay list" }
+      ]
+    },
+    {
+      title: " Search Syntax ",
+      titleColor: "teal",
+      rows: [
+        { keys: "keywords", action: "Free-text search" },
+        { keys: "key:value", action: "Qualifier filter" },
+        { keys: "-key:value", action: "Negated qualifier" },
+        { keys: '"phrase"', action: "Exact phrase match" }
+      ]
+    },
+    {
+      title: " Qualifiers ",
+      titleColor: "muted",
+      rows: [
+        { keys: "language:", action: "Filter by language" },
+        { keys: "stars:>N", action: "Minimum stars" },
+        { keys: "fork:true", action: "Include forks" },
+        { keys: "user:", action: "User's repos" },
+        { keys: "org:", action: "Organization repos" },
+        { keys: "repo:", action: "Specific repo" },
+        { keys: "topic:", action: "Filter by topic" },
+        { keys: "license:", action: "License type" },
+        { keys: "pushed:>YYYY-MM-DD", action: "Last push date" },
+        { keys: "archived:false", action: "Exclude archived" }
+      ]
+    },
+    {
+      title: " Rate Limits ",
+      titleColor: "orange",
+      rows: [
+        { keys: "No token", action: "10 req / min" },
+        { keys: "GITHUB_TOKEN", action: "30 req / min (or your plan limit)" }
+      ],
+      note: "Set GITHUB_TOKEN in your environment or add to config."
+    }
+  ];
+}
+var HELP_KEYS_COLUMN = 24;
+
+// src/storage.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync as writeFileSync2, appendFileSync, unlinkSync } from "fs";
+import { join } from "path";
+function ensureDir() {
+  mkdirSync(stateDir(), { recursive: true });
+}
+function readJSON(filename, fallback) {
+  ensureDir();
+  try {
+    return JSON.parse(readFileSync(join(stateDir(), filename), "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJSON(filename, data) {
+  ensureDir();
+  writeFileSync2(join(stateDir(), filename), JSON.stringify(data, null, 2));
+}
+function appendJSONL(filename, obj) {
+  ensureDir();
+  try {
+    appendFileSync(join(stateDir(), filename), JSON.stringify(obj) + "\n", "utf-8");
+  } catch {
+  }
+}
+function readJSONL(filename) {
+  ensureDir();
+  try {
+    const raw = readFileSync(join(stateDir(), filename), "utf-8").trim();
+    if (!raw) return [];
+    return raw.split("\n").filter(Boolean).map((l) => JSON.parse(l));
+  } catch {
+    return [];
+  }
+}
+function writeRaw(filename, data) {
+  ensureDir();
+  writeFileSync2(join(stateDir(), filename), data);
+}
+function debugLog(msg) {
+  if (!process.env.DEBUG) return;
+  try {
+    appendFileSync(join(stateDir(), "ghfind-debug.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`, "utf-8");
+  } catch {
+  }
+}
+
+// src/history.ts
+var HISTORY_FILE = "history.jsonl";
+var MAX_ENTRIES = 500;
+function appendHistory(entry) {
+  appendJSONL(HISTORY_FILE, entry);
+}
+function readHistory() {
+  const entries = readJSONL(HISTORY_FILE);
+  entries.reverse();
+  const deduped = [];
+  let lastQuery;
+  for (const e of entries) {
+    if (e.query !== lastQuery) {
+      deduped.push(e);
+      lastQuery = e.query;
+    }
+  }
+  return deduped;
+}
+function deleteHistoryEntry(index) {
+  const entries = readHistory();
+  if (index < 0 || index >= entries.length) return;
+  const removed = entries[index];
+  const remaining = entries.filter((e) => e.timestamp !== removed.timestamp || e.query !== removed.query);
+  writeRaw(HISTORY_FILE, remaining.reverse().map((e) => JSON.stringify(e)).join("\n") + "\n");
+}
+function clearHistory() {
+  writeRaw(HISTORY_FILE, "");
+}
+function rotateHistory() {
+  const entries = readHistory();
+  if (entries.length <= MAX_ENTRIES) return;
+  const trimmed = entries.slice(0, MAX_ENTRIES);
+  writeRaw(HISTORY_FILE, trimmed.reverse().map((e) => JSON.stringify(e)).join("\n") + "\n");
+}
+
+// src/bookmarks.ts
+var BOOKMARK_FILE = "bookmarks.json";
+function loadRaw() {
+  return readJSON(BOOKMARK_FILE, []);
+}
+function saveRaw(bookmarks) {
+  writeJSON(BOOKMARK_FILE, bookmarks);
+}
+function getBookmarks() {
+  return loadRaw().sort((a, b) => b.savedAt - a.savedAt);
+}
+function toggleBookmark(repo, tags = []) {
+  const bookmarks = loadRaw();
+  const idx = bookmarks.findIndex((b) => b.repo.fullName === repo.fullName);
+  if (idx >= 0) {
+    bookmarks.splice(idx, 1);
+    saveRaw(bookmarks);
+    return false;
+  }
+  bookmarks.push({ repo, savedAt: Date.now(), tags });
+  saveRaw(bookmarks);
+  return true;
+}
+function removeBookmark(fullName) {
+  const bookmarks = loadRaw().filter((b) => b.repo.fullName !== fullName);
+  saveRaw(bookmarks);
+}
+
+// src/saved-searches.ts
+var SAVED_FILE = "saved-searches.json";
+function loadRaw2() {
+  return readJSON(SAVED_FILE, []);
+}
+function saveRaw2(searches) {
+  writeJSON(SAVED_FILE, searches);
+}
+function getSavedSearches() {
+  return loadRaw2().sort((a, b) => (b.lastRunAt ?? b.createdAt) - (a.lastRunAt ?? a.createdAt));
+}
+function saveSearch(name, query, mode, sort, limit, tab) {
+  const searches = loadRaw2();
+  const now = Date.now();
+  const existing = searches.findIndex((s) => s.name === name);
+  const entry = { name, query, mode, sort, limit, tab, createdAt: now, lastRunAt: now };
+  if (existing >= 0) {
+    searches[existing] = { ...searches[existing], ...entry, createdAt: searches[existing].createdAt };
+  } else {
+    searches.push(entry);
+  }
+  saveRaw2(searches);
+  return entry;
+}
+function deleteSavedSearch(name) {
+  saveRaw2(loadRaw2().filter((s) => s.name !== name));
+}
+function touchSavedSearch(name) {
+  const searches = loadRaw2();
+  const found = searches.find((s) => s.name === name);
+  if (found) {
+    found.lastRunAt = Date.now();
+    saveRaw2(searches);
+  }
+}
+
+// src/session.ts
+var SESSION_FILE = "session.json";
+function saveSession(state) {
+  try {
+    writeJSON(SESSION_FILE, state);
+  } catch (err) {
+    if (process.env.DEBUG)
+      console.error(`[ghfind] Failed to save session: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function restoreSession() {
+  return readJSON(SESSION_FILE, null);
+}
+
+// src/deepdive.ts
+var USER_AGENT = "ghfind/1.0";
+async function fetchDeepDive(repo, token) {
+  const auth = token ? { Authorization: `Bearer ${token}` } : {};
+  const headers = { "User-Agent": USER_AGENT, ...auth };
+  const [languagesRes, contributorsRes] = await Promise.all([
+    fetch(`https://api.github.com/repos/${repo.owner}/${repo.name}/languages`, { headers }),
+    fetch(`https://api.github.com/repos/${repo.owner}/${repo.name}/contributors?per_page=5`, { headers })
+  ]);
+  let readmeText = "";
+  for (const path of [`${repo.owner}/${repo.name}/main/README.md`, `${repo.owner}/${repo.name}/master/README.md`, `${repo.owner}/${repo.name}/main/README.rst`]) {
+    const r = await fetch(`https://raw.githubusercontent.com/${path}`, { headers });
+    if (r.ok) {
+      readmeText = await r.text();
+      break;
+    }
+  }
+  return {
+    summary: formatSummary(repo),
+    languages: formatLanguages(languagesRes.ok ? await languagesRes.json().catch(() => ({})) : {}),
+    contributors: formatContributors(contributorsRes.ok ? await contributorsRes.json().catch(() => []) : []),
+    readme: formatReadme(readmeText)
+  };
+}
+function formatSummary(repo) {
+  const lines = [
+    ` ${repo.fullName}`,
+    ` \u2605 ${repo.stars.toLocaleString()}  \u25C6 ${repo.forks.toLocaleString()}  ${repo.language ?? "\u2014"}`,
+    repo.description ? ` ${repo.description}` : "",
+    repo.topics.length ? ` topics: ${repo.topics.slice(0, 8).join(", ")}` : "",
+    ` ${repo.url}`
+  ];
+  return lines.filter(Boolean).join("\n");
+}
+function formatLanguages(langs) {
+  const entries = Object.entries(langs);
+  if (entries.length === 0) return "  (no language data)";
+  const total = entries.reduce((s, [, v]) => s + v, 0);
+  const barW = 20;
+  return entries.sort(([, a], [, b]) => b - a).slice(0, 8).map(([name, bytes]) => {
+    const pct = (bytes / total * 100).toFixed(1);
+    const filled = Math.round(bytes / total * barW);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(barW - filled);
+    return `  ${name.padEnd(16)} ${bar} ${pct}%`;
+  }).join("\n");
+}
+function formatContributors(contributors) {
+  if (contributors.length === 0) return "  (no contributor data)";
+  return contributors.slice(0, 5).map((c) => `  \u25B2 ${c.login.padEnd(20)} ${c.contributions} commits`).join("\n");
+}
+function formatReadme(readme) {
+  if (!readme) return "  (no README)";
+  const stripped = readme.replace(/```[\s\S]*?```/g, "[code block]").replace(/#{1,6}\s/g, "").replace(/\*\*(.+?)\*\*/g, "$1").replace(/\[(.+?)\]\(.+?\)/g, "$1").replace(/`([^`]+)`/g, "$1").split("\n").map((l) => l.trim()).filter(Boolean);
+  const lines = stripped.slice(0, 30);
+  if (stripped.length > 30) lines.push("... (more lines, open in browser to read full)");
+  return lines.map((l) => `  ${l}`).join("\n");
+}
+function buildDeepDiveText(data) {
+  return [
+    "\u2500\u2500 Summary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    data.summary,
+    "",
+    "\u2500\u2500 Languages \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    data.languages,
+    "",
+    "\u2500\u2500 Top Contributors \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    data.contributors,
+    "",
+    "\u2500\u2500 README \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    data.readme
+  ].join("\n");
+}
+
+// src/compare.ts
+function buildComparisonTable(repos) {
+  if (repos.length < 2) return "Select at least 2 repos to compare (press c to add).";
+  const rows = [];
+  const names = repos.map((r) => r.fullName);
+  rows.push({ label: "Stars", values: repos.map((r) => `\u2605 ${r.stars.toLocaleString()}`) });
+  rows.push({ label: "Forks", values: repos.map((r) => r.forks.toLocaleString()) });
+  rows.push({ label: "Language", values: repos.map((r) => r.language ?? "\u2014") });
+  rows.push({ label: "Created", values: repos.map((r) => r.createdAt?.slice(0, 7) ?? "\u2014") });
+  rows.push({ label: "Updated", values: repos.map((r) => r.updatedAt?.slice(0, 10) ?? "\u2014") });
+  rows.push({ label: "Topics", values: repos.map((r) => (r.topics?.slice(0, 3).join(", ") ?? "\u2014") || "\u2014") });
+  const colW = Math.max(15, ...names.map((n) => n.length));
+  const valW = Math.max(8, ...rows.flatMap((r) => r.values.map((v) => v.length)));
+  const header = ["".padEnd(14), ...names.map((n) => n.padEnd(colW))];
+  const sep = ["".padEnd(14, "\u2500"), ...names.map(() => "".padEnd(colW, "\u2500"))];
+  const lines = [
+    "\u250C" + sep.map((s) => "\u2500" + s + "\u2500").join("\u252C") + "\u2510",
+    "\u2502" + header.map((h) => ` ${h} `).join("\u2502") + "\u2502",
+    "\u251C" + sep.map((s) => "\u2500" + s + "\u2500").join("\u253C") + "\u2524"
+  ];
+  for (const row of rows) {
+    const cells = [row.label.padEnd(14), ...row.values.map((v) => v.padEnd(colW))];
+    lines.push("\u2502" + cells.map((c) => ` ${c} `).join("\u2502") + "\u2502");
+  }
+  lines.push("\u2514" + sep.map((s) => "\u2500" + s + "\u2500").join("\u2534") + "\u2518");
+  return lines.join("\n");
+}
+
+// src/explore.ts
+async function fetchTopics() {
+  const res = await fetch("https://api.github.com/search/topics?q=popular&per_page=30", {
+    headers: {
+      Accept: "application/vnd.github.mercy-preview+json",
+      "User-Agent": "search-cli"
+    }
+  });
+  if (!res.ok) throw new Error(`Topics API: HTTP ${res.status}`);
+  const data = await res.json();
+  return (data.items ?? []).map((item) => ({
+    name: item.name,
+    description: item.description || "",
+    repoCount: item.score || 0
+  }));
+}
+
+// src/status.ts
+var SEARCH_SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var LOADING_SPINNER = ["\u25B0\u25B1\u25B1\u25B1\u25B1", "\u25B0\u25B0\u25B1\u25B1\u25B1", "\u25B0\u25B0\u25B0\u25B1\u25B1", "\u25B0\u25B0\u25B0\u25B0\u25B1", "\u25B0\u25B0\u25B0\u25B0\u25B0"];
+var StatusManager = class {
+  spinnerInterval = null;
+  spinnerIndex = 0;
+  type = "idle";
+  message = "";
+  onUpdate;
+  constructor(onUpdate) {
+    this.onUpdate = onUpdate;
+  }
+  set(type, message) {
+    this.stopSpinner();
+    this.type = type;
+    this.message = message;
+    if (type === "searching" || type === "loading") {
+      this.startSpinner(type === "searching" ? SEARCH_SPINNER : LOADING_SPINNER);
+    } else {
+      this.emit();
+    }
+  }
+  startSpinner(frames) {
+    this.spinnerIndex = 0;
+    this.emit(frames[0]);
+    this.spinnerInterval = setInterval(() => {
+      this.spinnerIndex = (this.spinnerIndex + 1) % frames.length;
+      this.emit(frames[this.spinnerIndex]);
+    }, 120);
+  }
+  stopSpinner() {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = null;
+    }
+  }
+  emit(spinner) {
+    const icon = this.type === "searching" ? "\u{1F50D}" : this.type === "loading" ? "\u{1F4E6}" : this.type === "success" ? "\u2713" : this.type === "error" ? "\u26A0" : " ";
+    const prefix = spinner ?? "";
+    this.onUpdate(`${icon} ${this.message}  ${prefix}`.trim());
+  }
+  dispose() {
+    this.stopSpinner();
+  }
+};
+
+// src/notifications.ts
+var nextId = 1;
+var notifs = [];
+var FILE = "notifications.json";
+function load() {
+  notifs = readJSON(FILE, []);
+  nextId = Math.max(...notifs.map((n) => n.id), 0) + 1;
+}
+function save() {
+  writeJSON(FILE, notifs);
+}
+function getNotifications() {
+  if (notifs.length === 0) load();
+  return [...notifs];
+}
+function dismissNotification(id) {
+  notifs = notifs.filter((n) => n.id !== id);
+  save();
+}
+function dismissAll() {
+  notifs = [];
+  save();
+}
+
+// src/share.ts
+import { spawn } from "child_process";
+function formatShare(repo, format2) {
+  switch (format2) {
+    case "markdown":
+      return `[${repo.fullName}](${repo.url}) \u2014 ${repo.description ?? ""}`.trim();
+    case "plain":
+      return `${repo.fullName} \u2014 ${repo.description ?? ""} \u2014 ${repo.url}`.trim();
+    case "gh-cli":
+      return `gh repo view ${repo.fullName}`;
+    case "short":
+      return repo.fullName;
+  }
+}
+async function copyToClipboard(text) {
+  try {
+    const p = process.platform;
+    const cmd = p === "win32" ? ["clip"] : p === "darwin" ? ["pbcopy"] : await findLinuxClipCmd();
+    if (!cmd) return false;
+    const proc = spawn(cmd[0], cmd.slice(1), { stdio: ["pipe", "ignore", "ignore"] });
+    proc.stdin.write(text);
+    proc.stdin.end();
+    return new Promise((resolve) => {
+      proc.on("close", (code) => resolve(code === 0));
+      proc.on("error", () => resolve(false));
+    });
+  } catch {
+    return false;
+  }
+}
+
+// src/tips.ts
+var TIPS = [
+  "\u{1F4A1} Tip: Press ? to see all keyboard shortcuts",
+  "\u{1F4A1} Tip: Use Ctrl+R to recall past searches",
+  "\u{1F4A1} Tip: Press b to bookmark a repository",
+  "\u{1F4A1} Tip: Tab auto-completes qualifiers like language: and stars:",
+  "\u{1F4A1} Tip: Press Ctrl+E to export results as CSV or Markdown",
+  "\u{1F4A1} Tip: Set GITHUB_TOKEN for higher API rate limits",
+  "\u{1F4A1} Tip: Press c to compare up to 5 repos side-by-side",
+  "\u{1F4A1} Tip: Press d for a deep-dive into any repo",
+  "\u{1F4A1} Tip: Press E to browse popular GitHub topics",
+  "\u{1F4A1} Tip: Press Ctrl+P to copy a repo link to clipboard"
+];
+var lastIndex = -1;
+function nextTip() {
+  let idx;
+  do {
+    idx = Math.floor(Math.random() * TIPS.length);
+  } while (idx === lastIndex && TIPS.length > 1);
+  lastIndex = idx;
+  return TIPS[idx];
+}
+
+// src/tui.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/update-check.ts
+var REGISTRY_URL = "https://registry.npmjs.org/github-search-cli/latest";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var REQUEST_TIMEOUT_MS = 5e3;
+var STATE_FILE = "update-state.json";
+var DEFAULTS = {
+  lastCheck: 0,
+  snoozeUntil: 0,
+  suppressed: false
+};
+function readUpdateState() {
+  return { ...DEFAULTS, ...readJSON(STATE_FILE, {}) };
+}
+function writeUpdateState(state) {
+  writeJSON(STATE_FILE, state);
+}
+function shouldCheckUpdate() {
+  const state = readUpdateState();
+  if (state.suppressed) return false;
+  if (Date.now() < state.snoozeUntil) return false;
+  if (Date.now() - state.lastCheck < CHECK_INTERVAL_MS) return false;
+  return true;
+}
+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]));
+  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;
+  }
+  return false;
+}
+async function checkForUpdate(currentVersion) {
+  if (process.env.DEBUG) debugLog(`Checking for update (current: ${currentVersion})`);
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      if (process.env.DEBUG) debugLog(`Registry returned ${res.status}`);
+      return null;
+    }
+    const data = await res.json();
+    const latest = data.version;
+    if (!latest) {
+      if (process.env.DEBUG) debugLog("No version in registry response");
+      return null;
+    }
+    if (process.env.DEBUG) debugLog(`Registry latest: ${latest}`);
+    if (!isNewerVersion(currentVersion, latest)) return null;
+    return latest;
+  } catch (e) {
+    if (process.env.DEBUG) debugLog(`Update check failed: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+function markUpdateChecked(latestVersion) {
+  writeUpdateState({
+    ...readUpdateState(),
+    lastCheck: Date.now(),
+    latestVersion
+  });
+}
+function snoozeUpdateNotices(days) {
+  writeUpdateState({
+    ...readUpdateState(),
+    snoozeUntil: Date.now() + days * 24 * 60 * 60 * 1e3
+  });
+}
+function suppressUpdateNotices() {
+  writeUpdateState({
+    ...readUpdateState(),
+    suppressed: true
+  });
+}
+async function performUpdate() {
+  const isBun = typeof process.versions !== "undefined" && "bun" in process.versions;
+  const cmd = isBun ? ["bun", "install", "-g", "ghfind"] : ["npm", "install", "-g", "ghfind"];
+  try {
+    const proc = Bun.spawn(cmd, {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await proc.exited;
+    if (proc.exitCode !== 0) {
+      const err = await proc.stderr.text();
+      debugLog(`Install failed (code ${proc.exitCode}): ${err}`);
+    }
+    return proc.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/tui.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PKG_DIR = join2(__dirname, "..");
+var cachedVersion = null;
+var colors = {
+  bg: "#3D3B3B",
+  surface: "#4a4848",
+  surfaceAlt: "#525050",
+  text: "#e0e4f0",
+  muted: "#a8a6a6",
+  blue: "#89b4fa",
+  green: "#a6e3a1",
+  yellow: "#f9e2af",
+  red: "#f38ba8",
+  teal: "#94e2d5",
+  purple: "#cba6f7",
+  orange: "#fab387",
+  border: "#1C1C1C",
+  borderAlt: "#2a2a2a",
+  separator: "#1C1C1C",
+  // Dark thin colorblock - thicker than border, visible separation
+  selectionBg: "#2A2A9C",
+  selectionText: "#ffffff",
+  // Premium accents for the command menu
+  accent: "#89b4fa",
+  accentDim: "#587cf5",
+  surfaceDim: "#1a1919",
+  borderAccent: "#1a1919"
+};
+var logger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var SORT_MODES = [
+  { key: "best-match", label: "best-match" },
+  { key: "stars", label: "stars" },
+  { key: "updated", label: "updated" },
+  { key: "forks", label: "forks" }
+];
+async function launchBrowser() {
+  let renderer;
+  try {
+    renderer = await createCliRenderer2();
+  } catch (err) {
+    const isNode = process.versions.bun === void 0;
+    if (isNode) {
+      console.error("\n\u274C  The interactive TUI requires Bun runtime.\n");
+      console.error("  Install Bun:  curl -fsSL https://bun.sh/install | bash");
+      console.error("  Then run:    bunx ghfind");
+      console.error("\n  Or use non-interactive mode (works on Node.js):");
+      console.error(`  ghfind "language:Rust" --json | jq '.[].fullName'`);
+      console.error("  ghfind --trending --count");
+    } else {
+      console.error(
+        "Failed to start the interactive browser. OpenTUI native backend unavailable.\n",
+        `Reason: ${err instanceof Error ? err.message : String(err)}
+`,
+        "Install Zig or use a platform with native OpenTUI support."
+      );
+    }
+    process.exit(1);
+    return;
+  }
+  const root = renderer.root;
+  root.flexDirection = "column";
+  root.backgroundColor = colors.bg;
+  const config = loadConfig();
+  const githubToken = config.githubToken || process.env.GITHUB_TOKEN;
+  const theme = loadTheme(config.theme);
+  Object.assign(colors, theme);
+  const session = restoreSession();
+  let currentRepos = [];
+  let currentSort = session?.sort ?? config.defaultSort;
+  let currentLimit = session?.limit ?? config.defaultLimit;
+  let currentQueryInput = session?.query ?? "";
+  let isLoading = false;
+  let currentMode = session?.mode ?? "search";
+  let trendingTab = session?.trendingTab ?? "This Week";
+  let trendingPeriod = "this week";
+  let graphFullscreen = false;
+  let chartCommitData = [];
+  let currentOverlay = "none";
+  let currentPage = 1;
+  let totalCount = 0;
+  let deepDiveActive = false;
+  let compareList = [];
+  let quitArmed = false;
+  const header = new TextRenderable2(renderer, {
+    content: " ghfind \u2014 GitHub repo browser   [/]search  [Space]menu  [\u2192]open  [?]help  [q]uit",
+    backgroundColor: colors.bg,
+    color: colors.muted,
+    height: 1,
+    borderBottom: true,
+    borderBottomColor: colors.border
+  });
+  const trendingTabBox = new BoxRenderable2(renderer, {
+    flexDirection: "row",
+    height: 1,
+    backgroundColor: colors.surface,
+    // No border — pure contract-edge separation via text contrast
+    paddingX: 1,
+    visible: false
+  });
+  const trendingTabTexts = [];
+  function renderTrendingTabs() {
+    for (const t2 of trendingTabTexts) trendingTabBox.remove(t2);
+    trendingTabTexts.length = 0;
+    TAB_NAMES.forEach((name, i) => {
+      const isActive = name === trendingTab;
+      const label = ` ${name} `;
+      const tt = new TextRenderable2(renderer, {
+        content: label,
+        color: isActive ? colors.bg : colors.muted,
+        backgroundColor: isActive ? colors.blue : colors.bg,
+        height: 1
+      });
+      trendingTabTexts.push(tt);
+      trendingTabBox.add(tt);
+      if (i < TAB_NAMES.length - 1) {
+        const sp = new TextRenderable2(renderer, {
+          content: "  ",
+          color: colors.muted,
+          backgroundColor: colors.bg,
+          height: 1
+        });
+        trendingTabTexts.push(sp);
+        trendingTabBox.add(sp);
+      }
+    });
+  }
+  root.add(header);
+  root.add(trendingTabBox);
+  const searchBox = new BoxRenderable2(renderer, {
+    visible: true,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " SEARCH ",
+    titleColor: colors.blue,
+    width: "100%",
+    flexDirection: "row",
+    paddingTop: 0,
+    paddingBottom: 0,
+    backgroundColor: colors.surface
+  });
+  const searchInput = new InputRenderable(renderer, {
+    placeholder: "Search GitHub repos (e.g. rust cli, or language:Rust stars:>100)",
+    value: "",
+    backgroundColor: colors.surface,
+    textColor: colors.text,
+    borderColor: colors.blue,
+    selectedBorderColor: colors.blue,
+    paddingX: 0,
+    flexGrow: 1
+  });
+  searchBox.add(searchInput);
+  root.add(searchBox);
+  const toolbarText = new TextRenderable2(renderer, {
+    content: formatToolbar(currentSort, currentLimit, totalCount),
+    visible: true,
+    // hidden in trending mode
+    backgroundColor: colors.surface,
+    // Surface panel
+    color: colors.muted,
+    height: 1,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    paddingX: 1
+  });
+  root.add(toolbarText);
+  const body = new BoxRenderable2(renderer, {
+    flexDirection: "row",
+    flexGrow: 1,
+    gap: 1,
+    paddingY: 1,
+    paddingX: 1
+  });
+  const resultsBox = new BoxRenderable2(renderer, {
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Results ",
+    titleColor: colors.blue,
+    width: "50%",
+    flexDirection: "column",
+    paddingLeft: 0,
+    focusable: false
+  });
+  const resultsSelect = new SelectRenderable(renderer, {
+    options: [
+      {
+        name: "",
+        description: "Type a query and press Enter to search",
+        value: null
+      }
+    ],
+    showDescription: false,
+    showSelectionIndicator: false,
+    flexGrow: 1,
+    textColor: colors.text,
+    selectedBackgroundColor: colors.selectionBg,
+    selectedTextColor: colors.selectionText,
+    focusedBackgroundColor: colors.bg,
+    focusedTextColor: colors.text,
+    itemSpacing: 0
+  });
+  resultsBox.add(resultsSelect);
+  const detailBox = new BoxRenderable2(renderer, {
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Details ",
+    titleColor: colors.green,
+    width: "50%",
+    flexDirection: "column",
+    paddingX: 1,
+    paddingY: 1,
+    focusable: false,
+    backgroundColor: colors.surface
+  });
+  const detailText = new TextRenderable2(renderer, {
+    content: "",
+    color: colors.text
+  });
+  detailBox.add(detailText);
+  body.add(resultsBox);
+  body.add(detailBox);
+  root.add(body);
+  function hideMainContent() {
+    trendingTabBox.visible = false;
+    searchBox.visible = false;
+    toolbarText.visible = false;
+    body.visible = false;
+  }
+  function showMainContent() {
+    if (currentMode === "trending") {
+      trendingTabBox.visible = true;
+    } else {
+      searchBox.visible = true;
+      toolbarText.visible = true;
+    }
+    body.visible = true;
+  }
+  function showOverlay(type) {
+    helpBox.visible = false;
+    historyBox.visible = false;
+    bookmarksBox.visible = false;
+    savedBox.visible = false;
+    topicsBox.visible = false;
+    exportBox.visible = false;
+    compareBox.visible = false;
+    notifsBox.visible = false;
+    shareBox.visible = false;
+    leaderBox.visible = false;
+    leaderDim.visible = false;
+    readmeBox.visible = false;
+    updateBox.visible = false;
+    updateDim.visible = false;
+    if (type === "none") {
+      currentOverlay = "none";
+      showMainContent();
+      renderer.requestRender();
+      return;
+    }
+    currentOverlay = type;
+    if (type !== "leader") {
+      hideMainContent();
+    }
+    if (type === "help") {
+      helpBox.visible = true;
+    } else if (type === "history") {
+      historyBox.visible = true;
+    } else if (type === "bookmarks") {
+      bookmarksBox.visible = true;
+    } else if (type === "saved") {
+      savedBox.visible = true;
+    } else if (type === "topics") {
+      topicsBox.visible = true;
+    } else if (type === "export") {
+      exportBox.visible = true;
+    } else if (type === "compare") {
+      compareBox.visible = true;
+    } else if (type === "notifications") {
+      notifsBox.visible = true;
+    } else if (type === "share") {
+      shareBox.visible = true;
+    } else if (type === "leader") {
+      leaderDim.visible = true;
+      leaderBox.visible = true;
+    } else if (type === "readme") {
+      readmeBox.visible = true;
+    } else if (type === "update") {
+      updateDim.visible = true;
+      updateBox.visible = true;
+      updateSelect.focus();
+    }
+    renderer.requestRender();
+  }
+  const helpSections = buildHelpSections();
+  const helpBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    borderBottom: true,
+    borderBottomColor: colors.border
+  });
+  const helpScroll = new ScrollBoxRenderable2(renderer, {
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    scrollY: true,
+    scrollX: false,
+    paddingX: 0,
+    viewportOptions: { backgroundColor: colors.bg },
+    contentOptions: { backgroundColor: colors.bg, flexDirection: "column" },
+    scrollbarOptions: {
+      backgroundColor: colors.bg,
+      foregroundColor: colors.muted,
+      width: 1
+    }
+  });
+  for (const section of helpSections) {
+    const sectionBox = new BoxRenderable2(renderer, {
+      borderBottom: true,
+      borderBottomColor: colors.border,
+      title: section.title,
+      titleColor: colors[section.titleColor] ?? section.titleColor,
+      flexDirection: "column",
+      paddingY: 0,
+      marginLeft: 1,
+      marginRight: 1,
+      marginTop: 1
+    });
+    for (const row of section.rows) {
+      const keys = row.keys.padEnd(HELP_KEYS_COLUMN);
+      sectionBox.add(
+        new TextRenderable2(renderer, {
+          content: `  ${keys} ${row.action}`,
+          color: colors.text
+        })
+      );
+    }
+    if (section.note) {
+      sectionBox.add(
+        new TextRenderable2(renderer, {
+          content: `  ${section.note}`,
+          color: colors.muted
+        })
+      );
+    }
+    helpScroll.add(sectionBox);
+  }
+  helpBox.add(helpScroll);
+  root.add(helpBox);
+  const historyBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Search History ",
+    titleColor: colors.blue
+  });
+  const historySelect = new SelectRenderable(renderer, {
+    options: [{ name: "(no history)", description: "", value: null }],
+    showDescription: false,
+    showSelectionIndicator: true,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    textColor: colors.text,
+    selectedBackgroundColor: colors.selectionBg,
+    selectedTextColor: colors.selectionText,
+    itemSpacing: 0
+  });
+  historyBox.add(historySelect);
+  root.add(historyBox);
+  function refreshHistory() {
+    const entries = readHistory();
+    if (entries.length === 0) {
+      historySelect.options = [
+        { name: "(no history)", description: "", value: null }
+      ];
+    } else {
+      historySelect.options = entries.map((e, i) => ({
+        name: `${e.query}  \u2014 ${e.mode}${e.tab ? ` (${e.tab})` : ""}`,
+        description: `${e.resultCount} results`,
+        value: { index: i, entry: e }
+      }));
+    }
+    historySelect.setSelectedIndex(0);
+  }
+  const bookmarksBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Bookmarks ",
+    titleColor: colors.green
+  });
+  const bookmarksSelect = new SelectRenderable(renderer, {
+    options: [{ name: "(no bookmarks)", description: "", value: null }],
+    showDescription: false,
+    showSelectionIndicator: true,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    textColor: colors.text,
+    selectedBackgroundColor: colors.selectionBg,
+    selectedTextColor: colors.selectionText,
+    itemSpacing: 0
+  });
+  bookmarksBox.add(bookmarksSelect);
+  root.add(bookmarksBox);
+  function refreshBookmarks() {
+    const bookmarks = getBookmarks();
+    if (bookmarks.length === 0) {
+      bookmarksSelect.options = [
+        { name: "(no bookmarks)", description: "", value: null }
+      ];
+    } else {
+      bookmarksSelect.options = bookmarks.map((b) => ({
+        name: `${b.repo.fullName}  \u2605 ${b.repo.stars.toLocaleString()}`,
+        description: b.repo.description ?? "",
+        value: b
+      }));
+    }
+    bookmarksSelect.setSelectedIndex(0);
+  }
+  const savedBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Saved Searches ",
+    titleColor: colors.yellow
+  });
+  const savedSelect = new SelectRenderable(renderer, {
+    options: [{ name: "(no saved searches)", description: "", value: null }],
+    showDescription: false,
+    showSelectionIndicator: true,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    textColor: colors.text,
+    selectedBackgroundColor: colors.selectionBg,
+    selectedTextColor: colors.selectionText,
+    itemSpacing: 0
+  });
+  savedBox.add(savedSelect);
+  root.add(savedBox);
+  const topicsBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Topics ",
+    titleColor: colors.purple ?? colors.blue
+  });
+  const topicsSelect = new SelectRenderable(renderer, {
+    options: [{ name: "(loading topics...)", description: "", value: null }],
+    showDescription: true,
+    showSelectionIndicator: true,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    textColor: colors.text,
+    selectedBackgroundColor: colors.selectionBg,
+    selectedTextColor: colors.selectionText,
+    itemSpacing: 0
+  });
+  topicsBox.add(topicsSelect);
+  root.add(topicsBox);
+  async function refreshTopics() {
+    try {
+      const topics = await fetchTopics();
+      topicsSelect.options = topics.map((t2) => ({
+        name: `${t2.name}  (${t2.repoCount.toLocaleString()} repos)`,
+        description: t2.description.slice(0, 80),
+        value: t2
+      }));
+    } catch {
+      topicsSelect.options = [
+        { name: "(failed to load topics)", description: "", value: null }
+      ];
+    }
+    topicsSelect.setSelectedIndex(0);
+  }
+  const exportBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Export ",
+    titleColor: colors.green
+  });
+  const exportSelect = new SelectRenderable(renderer, {
+    options: [
+      {
+        name: "  JSON",
+        description: "Full repo data as JSON array",
+        value: "json"
+      },
+      {
+        name: "  CSV",
+        description: "Rank, name, stars, forks, language, URL",
+        value: "csv"
+      },
+      {
+        name: "  Markdown",
+        description: "Pretty table with links (paste into README)",
+        value: "markdown"
+      },
+      { name: "  Plain text", description: "One repo per line", value: "text" }
+    ],
+    showDescription: true,
+    showSelectionIndicator: true,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    textColor: colors.text,
+    selectedBackgroundColor: colors.selectionBg,
+    selectedTextColor: colors.selectionText,
+    itemSpacing: 0
+  });
+  exportBox.add(exportSelect);
+  root.add(exportBox);
+  const compareBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Comparison ",
+    titleColor: colors.yellow
+  });
+  const compareText = new TextRenderable2(renderer, {
+    content: "",
+    color: colors.text,
+    backgroundColor: colors.bg
+  });
+  compareBox.add(compareText);
+  root.add(compareBox);
+  const notifsBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Notifications ",
+    titleColor: colors.yellow
+  });
+  const notifsText = new TextRenderable2(renderer, {
+    content: "(no notifications)",
+    color: colors.text,
+    backgroundColor: colors.bg
+  });
+  notifsBox.add(notifsText);
+  root.add(notifsBox);
+  function refreshNotifications() {
+    const notifs2 = getNotifications();
+    if (notifs2.length === 0) {
+      notifsText.content = "  (no notifications)";
+    } else {
+      notifsText.content = notifs2.map((n) => `  ${n.icon} ${n.message}`).join("\n");
+    }
+  }
+  const shareBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " Share Repo ",
+    titleColor: colors.blue
+  });
+  const shareSelect = new SelectRenderable(renderer, {
+    options: [
+      {
+        name: "  Markdown",
+        description: "[owner/repo](url) \u2014 description",
+        value: "markdown"
+      },
+      {
+        name: "  Plain",
+        description: "owner/repo \u2014 description \u2014 url",
+        value: "plain"
+      },
+      {
+        name: "  GitHub CLI",
+        description: "gh repo view owner/repo",
+        value: "gh-cli"
+      },
+      { name: "  Short", description: "owner/repo", value: "short" }
+    ],
+    showDescription: true,
+    showSelectionIndicator: true,
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    textColor: colors.text,
+    selectedBackgroundColor: colors.selectionBg,
+    selectedTextColor: colors.selectionText,
+    itemSpacing: 0
+  });
+  shareBox.add(shareSelect);
+  root.add(shareBox);
+  function refreshCompare() {
+    if (compareList.length < 2) {
+      compareText.content = "Select at least 2 repos to compare (press c to add).";
+    } else {
+      compareText.content = buildComparisonTable(compareList);
+    }
+  }
+  function refreshSavedSearches() {
+    const saved = getSavedSearches();
+    if (saved.length === 0) {
+      savedSelect.options = [
+        { name: "(no saved searches)", description: "", value: null }
+      ];
+    } else {
+      savedSelect.options = saved.map((s) => ({
+        name: `${s.name}`,
+        description: `${s.query}  (${s.mode})`,
+        value: s
+      }));
+    }
+    savedSelect.setSelectedIndex(0);
+  }
+  const leaderDim = new BoxRenderable2(renderer, {
+    visible: false,
+    position: "absolute",
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: "100%",
+    backgroundColor: "#00000099"
+    // 60% opacity black (hex alpha: 0x99 ≈ 153/255)
+  });
+  root.add(leaderDim);
+  const leaderBox = new BoxRenderable2(renderer, {
+    visible: false,
+    position: "absolute",
+    width: "80%",
+    height: 18,
+    left: "10%",
+    top: "30%",
+    backgroundColor: colors.surfaceDim,
+    border: true,
+    borderStyle: "rounded",
+    borderColor: colors.borderAccent,
+    title: " \u2699 Menu ",
+    titleColor: colors.accent,
+    titleAlignment: "left",
+    flexDirection: "column",
+    paddingX: 1
+  });
+  const leaderSelect = new SelectRenderable(renderer, {
+    options: [{ name: "(empty)", description: "", value: null }],
+    showDescription: true,
+    showSelectionIndicator: true,
+    flexGrow: 1,
+    backgroundColor: colors.surfaceDim,
+    textColor: colors.text,
+    focusedBackgroundColor: colors.surfaceDim,
+    focusedTextColor: colors.text,
+    selectedBackgroundColor: colors.accent,
+    selectedTextColor: colors.selectionText,
+    descriptionColor: colors.muted,
+    selectedDescriptionColor: colors.selectionText,
+    itemSpacing: 0
+  });
+  const leaderFooter = new TextRenderable2(renderer, {
+    content: " \u2191\u2193 select   Enter run   Esc/q close ",
+    color: colors.muted,
+    backgroundColor: colors.surfaceDim,
+    height: 1,
+    borderTop: true,
+    borderTopColor: colors.border,
+    paddingX: 2
+  });
+  leaderBox.add(leaderSelect);
+  leaderBox.add(leaderFooter);
+  root.add(leaderDim);
+  root.add(leaderBox);
+  const updateDim = new BoxRenderable2(renderer, {
+    visible: false,
+    position: "absolute",
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: "100%",
+    backgroundColor: "#00000088"
+  });
+  root.add(updateDim);
+  const updateBox = new BoxRenderable2(renderer, {
+    visible: false,
+    position: "absolute",
+    width: "55%",
+    height: 16,
+    left: "22.5%",
+    top: "25%",
+    backgroundColor: colors.surfaceDim,
+    border: true,
+    borderStyle: "rounded",
+    borderColor: colors.border,
+    title: " ghfind ",
+    titleColor: colors.accent,
+    titleAlignment: "left",
+    flexDirection: "column",
+    paddingX: 2,
+    paddingLeft: 2,
+    paddingRight: 2
+  });
+  const updateText = new TextRenderable2(renderer, {
+    content: "",
+    color: colors.accent,
+    backgroundColor: colors.surfaceDim
+  });
+  let updateSelectedOption = 0;
+  const updateOptionsRow = new BoxRenderable2(renderer, {
+    flexDirection: "row",
+    gap: 1,
+    backgroundColor: colors.surfaceDim,
+    height: 3,
+    width: "100%"
+  });
+  const updateNowBox = new BoxRenderable2(renderer, {
+    border: true,
+    borderColor: updateSelectedOption === 0 ? colors.yellow : colors.border,
+    backgroundColor: colors.surfaceDim,
+    height: 3,
+    width: "50%",
+    paddingLeft: 1,
+    paddingRight: 1
+  });
+  const updateNowText = new TextRenderable2(renderer, {
+    content: "   Update Now  ",
+    color: updateSelectedOption === 0 ? colors.yellow : colors.text,
+    backgroundColor: colors.surfaceDim
+  });
+  updateNowBox.add(updateNowText);
+  const laterBox = new BoxRenderable2(renderer, {
+    border: true,
+    borderColor: updateSelectedOption === 1 ? colors.yellow : colors.border,
+    backgroundColor: colors.surfaceDim,
+    height: 3,
+    width: "50%",
+    paddingLeft: 1,
+    paddingRight: 1
+  });
+  const laterText = new TextRenderable2(renderer, {
+    content: "  Later",
+    color: updateSelectedOption === 1 ? colors.yellow : colors.text,
+    backgroundColor: colors.surfaceDim
+  });
+  laterBox.add(laterText);
+  const neverBox = new BoxRenderable2(renderer, {
+    border: true,
+    borderColor: updateSelectedOption === 2 ? colors.yellow : colors.border,
+    backgroundColor: colors.surfaceDim,
+    height: 3,
+    width: "50%",
+    paddingLeft: 1,
+    paddingRight: 1
+  });
+  const neverText = new TextRenderable2(renderer, {
+    content: "  Don't show again",
+    color: updateSelectedOption === 2 ? colors.yellow : colors.text,
+    backgroundColor: colors.surfaceDim
+  });
+  neverBox.add(neverText);
+  function renderUpdateOptions() {
+    updateNowBox.borderColor = updateSelectedOption === 0 ? colors.yellow : colors.border;
+    laterBox.borderColor = updateSelectedOption === 1 ? colors.yellow : colors.border;
+    neverBox.borderColor = updateSelectedOption === 2 ? colors.yellow : colors.border;
+    updateNowText.color = updateSelectedOption === 0 ? colors.yellow : colors.text;
+    laterText.color = updateSelectedOption === 1 ? colors.yellow : colors.text;
+    neverText.color = updateSelectedOption === 2 ? colors.yellow : colors.text;
+    renderer.requestRender();
+  }
+  updateOptionsRow.add(updateNowBox);
+  updateOptionsRow.add(laterBox);
+  const updateFooter = new TextRenderable2(renderer, {
+    content: "  \u2190\u2192 select  Enter  Esc/q close",
+    color: colors.muted,
+    backgroundColor: colors.surfaceDim,
+    height: 1,
+    paddingX: 1
+  });
+  updateBox.add(updateText);
+  updateBox.add(updateOptionsRow);
+  updateBox.add(updateFooter);
+  root.add(updateDim);
+  root.add(updateBox);
+  const menuStack = [];
+  function pushMenuLevel(title, parentTitle, entries, selectIndex = 0) {
+    menuStack.push({
+      title,
+      parentTitle,
+      entries,
+      selectedIndex: leaderSelect.getSelectedIndex?.()
+    });
+    leaderSelect.options = entries.map((e) => ({
+      name: e.type === "category" ? `  ${e.icon} ${e.name} \u2192` : `  ${e.name}`,
+      description: e.description,
+      value: e
+    }));
+    leaderSelect.setSelectedIndex(selectIndex);
+    leaderBox.title = title;
+    const isTop = menuStack.length === 1;
+    leaderFooter.content = isTop ? "  \u2191\u2193 select  \u2192 open category  Enter run  Esc/q close" : "  Esc back  \u2191\u2193 select  Enter run";
+  }
+  function popMenuLevel() {
+    if (menuStack.length <= 1) return false;
+    const prev = menuStack[menuStack.length - 2];
+    const current = menuStack.pop();
+    leaderSelect.options = prev.entries.map((e) => ({
+      name: e.type === "category" ? `  ${e.icon} ${e.name} \u2192` : `  ${e.name}`,
+      description: e.description,
+      value: e
+    }));
+    leaderSelect.setSelectedIndex(current.selectedIndex);
+    leaderBox.title = prev.title;
+    const isTop = menuStack.length === 1;
+    leaderFooter.content = isTop ? "  \u2191\u2193 select  \u2192 open category  Enter run  Esc/q close" : "  Esc back  \u2191\u2193 select  Enter run";
+    return true;
+  }
+  function resetMenu() {
+    menuStack.length = 0;
+  }
+  function buildMenuHierarchy() {
+    const hasRepo = (() => {
+      const opt = resultsSelect.getSelectedOption();
+      return opt?.value && typeof opt.value?.fullName === "string";
+    })();
+    const groups = [];
+    const searchItems = [];
+    if (currentMode === "search") {
+      searchItems.push(
+        {
+          type: "action",
+          name: "Sort",
+          description: `Cycle sort (current: ${currentSort})`,
+          action: () => changeSort()
+        },
+        {
+          type: "action",
+          name: "Limit",
+          description: `Cycle result limit (current: ${currentLimit})`,
+          action: () => changeLimit()
+        },
+        {
+          type: "action",
+          name: "Refresh",
+          description: "Re-run current search",
+          action: () => {
+            if (currentQueryInput) doSearch(currentQueryInput);
+          }
+        },
+        {
+          type: "action",
+          name: "Save search",
+          description: "Save current query as a named search",
+          action: () => saveCurrentSearch()
+        },
+        {
+          type: "action",
+          name: "Saved searches",
+          description: "Load a saved search",
+          action: () => {
+            refreshSavedSearches();
+            showOverlay("saved");
+          }
+        }
+      );
+    }
+    if (searchItems.length > 0) {
+      groups.push({
+        type: "category",
+        name: "Search",
+        description: "Sort, limit, refresh, save searches",
+        icon: "\u{1F50D}",
+        children: searchItems
+      });
+    }
+    const repoItems = [];
+    if (hasRepo) {
+      repoItems.push(
+        {
+          type: "action",
+          name: "Open in browser",
+          description: "Open selected repo in browser",
+          action: () => openUrlIfSelected()
+        },
+        {
+          type: "action",
+          name: "Readme",
+          description: "Full README viewer",
+          action: () => {
+            showReadme();
+          }
+        },
+        {
+          type: "action",
+          name: "Activity graph",
+          description: "Toggle commit chart fullscreen",
+          action: () => toggleGraph()
+        }
+      );
+      if (currentMode === "search") {
+        repoItems.push({
+          type: "action",
+          name: "Deep-dive",
+          description: "Languages, contributors, README excerpt",
+          action: () => {
+            showOverlay("none");
+            triggerDeepDive();
+          }
+        });
+      }
+      repoItems.push(
+        {
+          type: "action",
+          name: "Bookmark",
+          description: "Save / unsave selected repo",
+          action: () => toggleBookmarkOnSelected()
+        },
+        {
+          type: "action",
+          name: "Compare",
+          description: "Add/remove repo to comparison",
+          action: () => toggleCompareOnSelected()
+        },
+        {
+          type: "action",
+          name: "Share",
+          description: "Copy repo link to clipboard",
+          action: () => showShareIfRepo()
+        }
+      );
+    }
+    if (repoItems.length > 0) {
+      groups.push({
+        type: "category",
+        name: "Repo",
+        description: "Open, readme, bookmark, share, compare",
+        icon: "\u{1F4CB}",
+        children: repoItems
+      });
+    }
+    const navItems = [];
+    if (currentMode === "search") {
+      navItems.push({
+        type: "action",
+        name: "Trending",
+        description: "Browse GitHub trending repos",
+        action: () => loadTrending()
+      });
+    } else {
+      navItems.push({
+        type: "action",
+        name: "Search mode",
+        description: "Switch to query search",
+        action: () => showSearchMode()
+      });
+    }
+    navItems.push(
+      {
+        type: "action",
+        name: "History",
+        description: "Search history",
+        action: () => {
+          refreshHistory();
+          showOverlay("history");
+        }
+      },
+      {
+        type: "action",
+        name: "Bookmarks",
+        description: "Browse saved repos",
+        action: () => {
+          refreshBookmarks();
+          showOverlay("bookmarks");
+        }
+      },
+      {
+        type: "action",
+        name: "Topics",
+        description: "Browse popular GitHub topics",
+        action: () => {
+          refreshTopics();
+          showOverlay("topics");
+        }
+      },
+      {
+        type: "action",
+        name: "Export",
+        description: "Export results to JSON/CSV/Markdown",
+        action: () => showOverlay("export")
+      }
+    );
+    groups.push({
+      type: "category",
+      name: "Navigate",
+      description: "Trending, history, bookmarks, topics, export",
+      icon: "\u{1F9ED}",
+      children: navItems
+    });
+    const sysItems = [
+      {
+        type: "action",
+        name: "Check for updates",
+        description: "Check npm for a newer version (debug)",
+        action: () => {
+          showOverlay("none");
+          checkForUpdateAndShow(true);
+        }
+      },
+      {
+        type: "action",
+        name: "Help",
+        description: "Keybindings reference",
+        action: () => showOverlay("help")
+      },
+      {
+        type: "action",
+        name: "Notifications",
+        description: "View alerts",
+        action: () => {
+          refreshNotifications();
+          showOverlay("notifications");
+        }
+      },
+      {
+        type: "action",
+        name: "Compare view",
+        description: "Show side-by-side comparison",
+        action: () => {
+          refreshCompare();
+          showOverlay("compare");
+        }
+      },
+      {
+        type: "action",
+        name: "Quit",
+        description: "Exit ghfind",
+        action: () => {
+          saveSession({
+            mode: currentMode,
+            query: currentQueryInput,
+            sort: currentSort,
+            limit: currentLimit,
+            trendingTab
+          });
+          cleanup();
+        }
+      }
+    ];
+    groups.push({
+      type: "category",
+      name: "System",
+      description: "Help, notifications, compare, quit",
+      icon: "\u2699\uFE0F",
+      children: sysItems
+    });
+    return groups;
+  }
+  function showLeaderMenu() {
+    resetMenu();
+    const topLevel = buildMenuHierarchy();
+    pushMenuLevel(" \u2699 Menu ", "", topLevel, 0);
+    leaderSelect.focus();
+    showOverlay("leader");
+  }
+  async function checkForUpdateAndShow(force = false) {
+    if (!force && !shouldCheckUpdate()) return;
+    if (cachedVersion === null) {
+      try {
+        const pkg = JSON.parse(readFileSync2(join2(PKG_DIR, "package.json"), "utf-8"));
+        cachedVersion = pkg.version;
+      } catch {
+        debugLog("Failed to read package.json");
+        return;
+      }
+    }
+    const currentVersion2 = cachedVersion;
+    const latest = process.env.DEBUG_FORCE_UPDATE || await checkForUpdate(currentVersion2);
+    markUpdateChecked(latest ?? void 0);
+    if (latest) {
+      updateSelectedOption = 0;
+      updateText.content = `  A new version is available
+
+  Current: ${currentVersion2}
+  Latest:   ${latest}
+
+  Run "npm install -g ghfind"`;
+      renderUpdateOptions();
+      showOverlay("update");
+    } else {
+      debugLog(`No update available (current: ${currentVersion2})`);
+    }
+  }
+  function openUrlIfSelected() {
+    const opt = resultsSelect.getSelectedOption();
+    const repo = opt?.value;
+    if (repo) openUrl(repo.url);
+    else setStatus("No repo selected");
+  }
+  function toggleBookmarkOnSelected() {
+    const opt = resultsSelect.getSelectedOption();
+    const repo = opt?.value;
+    if (repo) {
+      const added = toggleBookmark(repo);
+      setStatus(
+        added ? `Bookmarked ${repo.fullName}` : `Unbookmarked ${repo.fullName}`
+      );
+    }
+  }
+  function toggleCompareOnSelected() {
+    const opt = resultsSelect.getSelectedOption();
+    const repo = opt?.value;
+    if (!repo) return;
+    const idx = compareList.findIndex((r) => r.fullName === repo.fullName);
+    if (idx >= 0) {
+      compareList.splice(idx, 1);
+      setStatus(`Removed ${repo.fullName} from comparison`);
+    } else {
+      compareList.push(repo);
+      setStatus(
+        `${repo.fullName} added to comparison (${compareList.length} selected)`
+      );
+    }
+  }
+  function showShareIfRepo() {
+    const opt = resultsSelect.getSelectedOption();
+    const repo = opt?.value;
+    if (!repo) {
+      setStatus("No repo selected to share");
+      return;
+    }
+    showOverlay("share");
+  }
+  function saveCurrentSearch() {
+    if (currentQueryInput) {
+      const name = currentQueryInput.length > 40 ? currentQueryInput.slice(0, 37) + "..." : currentQueryInput;
+      saveSearch(
+        name,
+        currentQueryInput,
+        currentMode,
+        currentSort,
+        currentLimit,
+        currentMode === "trending" ? trendingTab : void 0
+      );
+      setStatus(`Saved as "${name}"`);
+    } else {
+      setStatus("No search to save");
+    }
+  }
+  function triggerDeepDive() {
+    const opt = resultsSelect.getSelectedOption();
+    const repo = opt?.value;
+    if (!repo) return;
+    deepDiveActive = !deepDiveActive;
+    if (deepDiveActive) {
+      detailText.content = "  Loading deep-dive...";
+      renderer.requestRender();
+      fetchDeepDive(repo, githubToken).then((data) => {
+        detailText.content = buildDeepDiveText(data);
+        renderer.requestRender();
+      }).catch(() => {
+        detailText.content = "  Failed to load deep-dive";
+        renderer.requestRender();
+      });
+    } else {
+      updateDetail(repo);
+      renderer.requestRender();
+    }
+  }
+  const readmeBox = new BoxRenderable2(renderer, {
+    visible: false,
+    flexGrow: 1,
+    backgroundColor: colors.surface,
+    borderBottom: true,
+    borderBottomColor: colors.border,
+    title: " README ",
+    titleColor: colors.green
+  });
+  const readmeScroll = new ScrollBoxRenderable2(renderer, {
+    flexGrow: 1,
+    backgroundColor: colors.bg,
+    scrollY: true,
+    scrollX: false,
+    paddingX: 1,
+    viewportOptions: { backgroundColor: colors.bg },
+    contentOptions: { backgroundColor: colors.bg, flexDirection: "column" },
+    scrollbarOptions: {
+      backgroundColor: colors.bg,
+      foregroundColor: colors.muted,
+      width: 1
+    }
+  });
+  const readmeText = new TextRenderable2(renderer, {
+    content: "",
+    color: colors.text,
+    backgroundColor: colors.bg
+  });
+  readmeScroll.add(readmeText);
+  readmeBox.add(readmeScroll);
+  const readmeFooter = new TextRenderable2(renderer, {
+    content: "  \u2191\u2193/jk scroll  Esc/q close",
+    color: colors.muted,
+    backgroundColor: colors.bg,
+    height: 1,
+    paddingX: 1
+  });
+  readmeBox.add(readmeFooter);
+  root.add(readmeBox);
+  async function showReadme() {
+    const opt = resultsSelect.getSelectedOption();
+    const repo = opt?.value;
+    if (!repo) {
+      setStatus("No repo selected");
+      return;
+    }
+    readmeText.content = `  Loading README for ${repo.fullName}...`;
+    showOverlay("readme");
+    try {
+      const headers = { "User-Agent": "ghfind/1.0" };
+      if (githubToken) headers.Authorization = `Bearer ${githubToken}`;
+      let text = "";
+      for (const path of [
+        `${repo.owner}/${repo.name}/main/README.md`,
+        `${repo.owner}/${repo.name}/master/README.md`,
+        `${repo.owner}/${repo.name}/main/README.rst`
+      ]) {
+        const r = await fetch(`https://raw.githubusercontent.com/${path}`, {
+          headers
+        });
+        if (r.ok) {
+          text = await r.text();
+          break;
+        }
+      }
+      if (!text) {
+        readmeText.content = `  (no README found for ${repo.fullName})`;
+      } else {
+        const stripped = text.replace(/```[\s\S]*?```/g, "[code block]").replace(/#{1,6}\s/g, "").replace(/\*\*(.+?)\*\*/g, "$1").replace(/\[(.+?)\]\(.+?\)/g, "$1").replace(/`([^`]+)`/g, "$1").split("\n").map((l) => l.trimEnd()).join("\n");
+        readmeText.content = stripped;
+      }
+    } catch {
+      readmeText.content = "  Failed to load README";
+    }
+    renderer.requestRender();
+  }
+  const statusBar = new TextRenderable2(renderer, {
+    content: " Ready. Press Enter to search.",
+    backgroundColor: colors.surface,
+    color: colors.muted,
+    height: 1,
+    paddingX: 1,
+    borderTop: true,
+    borderTopColor: colors.border
+  });
+  root.add(statusBar);
+  const statusMgr = new StatusManager((text) => {
+    statusBar.content = ` ${text}`;
+    renderer.requestRender();
+  });
+  if (config.theme !== void 0 || true) {
+    setTimeout(() => {
+      if (currentOverlay === "none") {
+        setStatus(nextTip());
+      }
+    }, 2e3);
+  }
+  function setStatus(msg) {
+    statusMgr.set("idle", msg);
+  }
+  function setToolbar() {
+    toolbarText.content = formatToolbar(currentSort, currentLimit, totalCount);
+    renderer.requestRender();
+  }
+  function updateDetail(repo) {
+    if (!repo) {
+      detailText.content = "";
+      return;
+    }
+    const topics = repo.topics.length ? repo.topics.slice(0, 8).join(", ") : "\u2014";
+    const desc = repo.description ?? "(no description)";
+    const stars = repo.stars.toLocaleString();
+    const forks = repo.forks.toLocaleString();
+    const lang = repo.language ?? "\u2014";
+    const updated = repo.updatedAt.slice(0, 10);
+    const statusTags = [];
+    if (repo.archived) statusTags.push("archived");
+    if (repo.isFork) statusTags.push("fork");
+    const tagStr = statusTags.length ? `  [${statusTags.join(", ")}]` : "";
+    const lines = [
+      `  ${repo.fullName}${tagStr}`,
+      ``,
+      `  \u2605  ${stars}    \u2661  ${forks}    ${lang}`,
+      `  Updated  ${updated}`,
+      `  Topics   ${topics}`,
+      ``,
+      `  ${desc}`,
+      ``,
+      `  ${repo.url}`
+    ];
+    detailText.content = lines.join("\n");
+  }
+  function brailleChar(bits) {
+    return bits === 0 ? " " : String.fromCodePoint(10240 + bits);
+  }
+  function buildChartString(values, termW, termH) {
+    if (values.length === 0) return ["(no data)"];
+    const dotW = termW * 2;
+    const dotH = termH * 4;
+    const sampled = [];
+    for (let i = 0; i < dotW; i++) {
+      sampled.push(values[Math.floor(i / dotW * values.length)]);
+    }
+    const max = Math.max(...sampled, 1);
+    const dotRows = sampled.map((v) => Math.round(v / max * (dotH - 1)));
+    const dotGrid = Array.from(
+      { length: dotH },
+      () => Array(dotW).fill(false)
+    );
+    for (let c = 0; c < dotW; c++) {
+      dotGrid[dotH - 1 - dotRows[c]][c] = true;
+    }
+    for (let c = 0; c < dotW - 1; c++) {
+      const r1 = dotRows[c];
+      const r2 = dotRows[c + 1];
+      const lo = Math.min(r1, r2);
+      const hi = Math.max(r1, r2);
+      for (let r = lo; r <= hi; r++) {
+        dotGrid[dotH - 1 - r][c] = true;
+      }
+    }
+    const lines = [];
+    for (let tr = 0; tr < termH; tr++) {
+      const chars = [];
+      for (let tc = 0; tc < termW; tc++) {
+        const r0 = tr * 4;
+        const c0 = tc * 2;
+        let bits = 0;
+        if (r0 + 0 < dotH && c0 + 0 < dotW && dotGrid[r0 + 0][c0 + 0])
+          bits |= 1;
+        if (r0 + 1 < dotH && c0 + 0 < dotW && dotGrid[r0 + 1][c0 + 0])
+          bits |= 2;
+        if (r0 + 2 < dotH && c0 + 0 < dotW && dotGrid[r0 + 2][c0 + 0])
+          bits |= 4;
+        if (r0 + 0 < dotH && c0 + 1 < dotW && dotGrid[r0 + 0][c0 + 1])
+          bits |= 8;
+        if (r0 + 1 < dotH && c0 + 1 < dotW && dotGrid[r0 + 1][c0 + 1])
+          bits |= 16;
+        if (r0 + 2 < dotH && c0 + 1 < dotW && dotGrid[r0 + 2][c0 + 1])
+          bits |= 32;
+        if (r0 + 3 < dotH && c0 + 0 < dotW && dotGrid[r0 + 3][c0 + 0])
+          bits |= 64;
+        if (r0 + 3 < dotH && c0 + 1 < dotW && dotGrid[r0 + 3][c0 + 1])
+          bits |= 128;
+        chars.push(brailleChar(bits));
+      }
+      const labelRows = [
+        0,
+        Math.floor(termH / 4),
+        Math.floor(termH / 2),
+        Math.floor(3 * termH / 4),
+        termH - 1
+      ];
+      const labelVals = [
+        max,
+        Math.round(max * 0.75),
+        Math.round(max / 2),
+        Math.round(max / 4),
+        0
+      ];
+      const idx = labelRows.indexOf(tr);
+      let label = "     ";
+      if (idx >= 0) {
+        const val = labelVals[idx];
+        label = val >= 1e3 ? `${(val / 1e3).toFixed(1).replace(/\.0$/, "")}k` : String(val);
+        label = label.padStart(5) + " ";
+      }
+      lines.push(`${label}\u2506${chars.join("")}`);
+    }
+    const xAxis = `     \u2506${"\u2500".repeat(termW)}`;
+    const weekLabels = `     \u2506 ${"1w".padEnd(Math.floor(termW / 4))} ${"13w".padEnd(Math.floor(termW / 4))} ${"26w".padEnd(Math.floor(termW / 4))} ${"52w"}`;
+    return [xAxis, weekLabels];
+  }
+  async function loadChart(repo) {
+    detailText.content = "  Loading chart...";
+    renderer.requestRender();
+    try {
+      const [chartRes, repoRes] = await Promise.all([
+        fetch(
+          `https://api.github.com/repos/${repo.owner}/${repo.name}/stats/participation`,
+          { headers: { "User-Agent": "ghfind/1.0" } }
+        ),
+        fetch(`https://api.github.com/repos/${repo.owner}/${repo.name}`, {
+          headers: { "User-Agent": "ghfind/1.0" }
+        }).then((r) => r.ok ? r.json() : null)
+      ]);
+      let chartSection = "";
+      if (chartRes.ok) {
+        const data = await chartRes.json();
+        if (data?.all && data.all.length >= 2) {
+          chartCommitData = data.all;
+          const chartW = 60;
+          const chartH = 10;
+          const chartLines = buildChartString(chartCommitData, chartW, chartH);
+          chartSection = ["", "Weekly commits (52 weeks)", ...chartLines].join(
+            "\n"
+          );
+        }
+      }
+      const desc = repo.description ?? "";
+      const lang = repo.language ?? "\u2014";
+      const updated = repo.updatedAt ? repo.updatedAt.slice(0, 10) : "";
+      const topics = repoRes?.topics?.length ? repoRes.topics.slice(0, 8).join(", ") : "";
+      const growthLine = currentMode === "trending" && repo.score > 0 ? ` Growth \u25B2 ${fmtStars(repo.score)} ${trendingPeriod}` : "";
+      const detailLines = [
+        `  ${repo.fullName}`,
+        ``,
+        `  \u2605  ${repo.stars.toLocaleString()}    \u2661  ${repo.forks.toLocaleString()}    ${lang}`,
+        growthLine,
+        updated ? ` Updated ${updated}` : "",
+        topics ? ` Topics  ${topics}` : "",
+        "",
+        desc,
+        "",
+        ` ${repo.url}`
+      ].filter((l) => l !== "");
+      detailText.content = [...detailLines, chartSection].join("\n");
+    } catch {
+      detailText.content = "  Failed to load chart";
+    }
+    renderer.requestRender();
+  }
+  function toggleGraph() {
+    graphFullscreen = !graphFullscreen;
+    if (graphFullscreen) {
+      resultsBox.visible = false;
+      resultsBox.width = "0%";
+      detailBox.width = "100%";
+      const opt = resultsSelect.getSelectedOption();
+      const repo = opt?.value;
+      if (repo) loadChart(repo);
+      else detailText.content = "  Select a repo to view activity";
+    } else {
+      resultsBox.visible = true;
+      resultsBox.width = "50%";
+      detailBox.width = "50%";
+      const opt = resultsSelect.getSelectedOption();
+      if (opt?.value) updateDetail(opt.value);
+      else detailText.content = "";
+    }
+    renderer.requestRender();
+  }
+  function formatTrendingLine(r, rank) {
+    const rankStr = String(rank).padStart(2, "0");
+    const name = `${r.owner}/${r.name}`.padEnd(30).slice(0, 30);
+    const lang = (r.language || "?").padEnd(12).slice(0, 12);
+    const stars = `\u2605 ${fmtStars(r.stars)}`.padEnd(9).slice(0, 9);
+    const arrow = r.score > 0 ? "\u25B2" : r.score < 0 ? "\u25BC" : "\u2014";
+    const growth = `${arrow} ${fmtStars(r.score)} ${trendingPeriod}`;
+    return `[${rankStr}] ${name} ${lang} ${stars} ${growth}`;
+  }
+  async function loadTrending() {
+    currentMode = "trending";
+    isLoading = true;
+    searchBox.visible = false;
+    toolbarText.visible = false;
+    trendingTabBox.visible = true;
+    renderTrendingTabs();
+    resultsSelect.options = [
+      { name: "  Loading trending...", description: "", value: null }
+    ];
+    detailText.content = "";
+    statusMgr.set("loading", "Loading trending repos...");
+    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 fetched = response.repos;
+      const since = tabSince(trendingTab);
+      trendingPeriod = since === "daily" ? "today" : since === "weekly" ? "this week" : "this month";
+      resultsSelect.options = fetched.map((r, i) => ({
+        name: formatTrendingLine(r, i + 1),
+        description: r.description ?? "",
+        value: r
+      }));
+      if (fetched.length > 0) {
+        resultsSelect.setSelectedIndex(0);
+        updateDetail(fetched[0]);
+      } else {
+        throw new NoResultsError(trendingTab);
+      }
+      statusMgr.set(
+        "success",
+        `${fetched.length} trending repos \u2014 ${trendingTab}`
+      );
+      appendHistory({
+        query: `trending:${trendingTab}`,
+        mode: "trending",
+        tab: trendingTab,
+        timestamp: Date.now(),
+        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));
+    }
+    isLoading = false;
+    renderer.requestRender();
+  }
+  function showSearchMode() {
+    currentMode = "search";
+    trendingTabBox.visible = false;
+    searchBox.visible = true;
+    toolbarText.visible = true;
+    searchInput.placeholder = "Search GitHub repos (e.g. rust cli, or language:Rust stars:>100)";
+    searchInput.focus();
+    renderer.requestRender();
+  }
+  async function doSearch(queryText, append = false) {
+    const q = queryText.trim();
+    if (q === "" || isLoading) return;
+    if (!append) currentPage = 1;
+    deepDiveActive = false;
+    isLoading = true;
+    currentQueryInput = q;
+    if (!append) {
+      resultsSelect.options = [
+        { name: "  Searching...", description: "", value: null }
+      ];
+      detailText.content = "";
+    }
+    statusMgr.set("searching", `Searching for "${q}"`);
+    try {
+      const parsed = applyFlagFilters(parseQuery(q), {});
+      validateQuery(parsed);
+      const provider = createGitHubSearch(logger);
+      const options = {
+        limit: currentLimit,
+        sort: currentSort,
+        json: false,
+        verbose: false,
+        token: githubToken,
+        page: currentPage
+      };
+      const response = await provider.search(parsed, options);
+      totalCount = response.totalCount;
+      const newRepos = rankRepos(response.repos, options.sort);
+      if (append) {
+        currentRepos.push(...newRepos);
+      } else {
+        currentRepos = newRepos;
+      }
+      if (currentRepos.length === 0) {
+        throw new NoResultsError(q);
+      } else {
+        resultsSelect.options = currentRepos.map((r) => ({
+          name: formatResultLine(r),
+          description: "",
+          value: r
+        }));
+        const idx = append ? resultsSelect.options.length - newRepos.length : 0;
+        updateDetail(currentRepos[idx]);
+        resultsSelect.setSelectedIndex(idx);
+        statusMgr.set(
+          "success",
+          `Page ${currentPage} \u2014 ${currentRepos.length} of ${totalCount.toLocaleString()} results`
+        );
+        if (!append) {
+          appendHistory({
+            query: q,
+            mode: "search",
+            timestamp: Date.now(),
+            resultCount: currentRepos.length
+          });
+        }
+      }
+    } catch (err) {
+      currentRepos = [];
+      resultsSelect.options = [
+        { 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));
+    }
+    isLoading = false;
+    renderer.requestRender();
+  }
+  function changeSort() {
+    const idx = SORT_MODES.findIndex((m) => m.key === currentSort);
+    const next = SORT_MODES[(idx + 1) % SORT_MODES.length];
+    currentSort = next.key;
+    setToolbar();
+    if (currentRepos.length > 0) {
+      currentRepos = rankRepos(currentRepos, currentSort);
+      resultsSelect.options = currentRepos.map((r) => ({
+        name: formatResultLine(r),
+        description: "",
+        value: r
+      }));
+      resultsSelect.setSelectedIndex(0);
+      updateDetail(currentRepos[0]);
+      renderer.requestRender();
+    }
+  }
+  function changeLimit() {
+    const limits = [10, 25, 50, 100];
+    const idx = limits.indexOf(currentLimit);
+    currentLimit = limits[(idx + 1) % limits.length];
+    setToolbar();
+    setStatus(`Limit set to ${currentLimit}. Press Enter to re-search.`);
+    renderer.requestRender();
+  }
+  searchInput.on("enter", () => {
+    if (searchInput.value.trim() === "" || isLoading) return;
+    showSearchMode();
+    doSearch(searchInput.value);
+  });
+  resultsSelect.on("selectionChanged", () => {
+    const opt = resultsSelect.getSelectedOption();
+    const repo = opt?.value;
+    if (repo) {
+      if (graphFullscreen) loadChart(repo);
+      else updateDetail(repo);
+    }
+    renderer.requestRender();
+  });
+  resultsSelect.on("itemSelected", () => {
+    const opt = resultsSelect.getSelectedOption();
+    const repo = opt?.value;
+    if (repo) openUrl(repo.url);
+  });
+  renderer.keyInput.on("keypress", (key) => {
+    if (currentOverlay !== "none") {
+      if (key.name === "escape") {
+        if (currentOverlay === "leader") {
+          if (!popMenuLevel()) {
+            showOverlay("none");
+          }
+          setToolbar();
+          renderer.requestRender();
+        } else {
+          showOverlay("none");
+          renderer.requestRender();
+        }
+        return;
+      }
+      if (key.name === "q") {
+        showOverlay("none");
+        renderer.requestRender();
+        return;
+      }
+      if (currentOverlay === "leader") {
+        if (key.name === "enter" || key.name === "return" || key.name === "right" || key.name === "l") {
+          const sel = leaderSelect.getSelectedOption();
+          const entry = sel?.value;
+          if (!entry) return;
+          if (entry.type === "category") {
+            pushMenuLevel(
+              `  Menu > ${entry.name}`,
+              entry.name,
+              entry.children,
+              0
+            );
+            renderer.requestRender();
+          } else {
+            resetMenu();
+            showOverlay("none");
+            entry.action();
+            renderer.requestRender();
+          }
+          return;
+        }
+        if (key.name === "left" || key.name === "h") {
+          if (popMenuLevel()) {
+            setToolbar();
+            renderer.requestRender();
+          }
+          return;
+        }
+      }
+      if (currentOverlay === "readme") {
+        return;
+      }
+      if (currentOverlay === "history") {
+        if (key.name === "d") {
+          const sel = historySelect.getSelectedOption();
+          if (sel?.value) {
+            deleteHistoryEntry(sel.value.index);
+            refreshHistory();
+            setStatus("Deleted history entry");
+          }
+          renderer.requestRender();
+          return;
+        }
+        if (key.ctrl && key.name === "x") {
+          clearHistory();
+          refreshHistory();
+          setStatus("History cleared");
+          renderer.requestRender();
+          return;
+        }
+        if (key.name === "enter" || key.name === "return") {
+          const sel = historySelect.getSelectedOption();
+          if (sel?.value) {
+            const entry = sel.value.entry;
+            showOverlay("none");
+            if (entry.mode === "trending") {
+              if (entry.tab)
+                trendingTab = entry.tab;
+              loadTrending();
+            } else {
+              searchInput.value = entry.query;
+              showSearchMode();
+              doSearch(entry.query);
+            }
+          }
+          return;
+        }
+        return;
+      }
+      if (currentOverlay === "bookmarks") {
+        if (key.name === "d") {
+          const sel = bookmarksSelect.getSelectedOption();
+          if (sel?.value) {
+            removeBookmark(sel.value.repo.fullName);
+            refreshBookmarks();
+            setStatus("Bookmark removed");
+          }
+          renderer.requestRender();
+          return;
+        }
+        if (key.name === "enter" || key.name === "return") {
+          const sel = bookmarksSelect.getSelectedOption();
+          if (sel?.value) openUrl(sel.value.repo.url);
+          return;
+        }
+        return;
+      }
+      if (currentOverlay === "saved") {
+        if (key.name === "d") {
+          const sel = savedSelect.getSelectedOption();
+          if (sel?.value) {
+            deleteSavedSearch(sel.value.name);
+            refreshSavedSearches();
+            setStatus("Saved search deleted");
+          }
+          renderer.requestRender();
+          return;
+        }
+        if (key.name === "enter" || key.name === "return") {
+          const sel = savedSelect.getSelectedOption();
+          if (sel?.value) {
+            const s = sel.value;
+            showOverlay("none");
+            touchSavedSearch(s.name);
+            if (s.mode === "trending") {
+              if (s.tab) trendingTab = s.tab;
+              loadTrending();
+            } else {
+              searchInput.value = s.query;
+              showSearchMode();
+              currentSort = s.sort;
+              currentLimit = s.limit;
+              setToolbar();
+              doSearch(s.query);
+            }
+          }
+          return;
+        }
+        return;
+      }
+      if (currentOverlay === "topics") {
+        if (key.name === "enter" || key.name === "return") {
+          const sel = topicsSelect.getSelectedOption();
+          if (sel?.value) {
+            const topic = sel.value;
+            showOverlay("none");
+            searchInput.value = `topic:${topic.name}`;
+            showSearchMode();
+            doSearch(`topic:${topic.name}`);
+          }
+          return;
+        }
+        return;
+      }
+      if (currentOverlay === "export") {
+        if (key.name === "enter" || key.name === "return") {
+          const sel = exportSelect.getSelectedOption();
+          if (sel?.value && currentRepos.length > 0) {
+            const format2 = sel.value;
+            const path = exportToFile(currentRepos, format2);
+            showOverlay("none");
+            setStatus(`\u2713 Exported to ${path}`);
+          } else {
+            setStatus("No results to export");
+            showOverlay("none");
+          }
+          renderer.requestRender();
+          return;
+        }
+        return;
+      }
+      if (currentOverlay === "compare") {
+        return;
+      }
+      if (currentOverlay === "notifications") {
+        if (key.name === "d") {
+          const notifs2 = getNotifications();
+          if (notifs2.length > 0) {
+            dismissNotification(notifs2[0].id);
+            refreshNotifications();
+            setStatus("Notification dismissed");
+          }
+          renderer.requestRender();
+          return;
+        }
+        if (key.ctrl && key.name === "c") {
+          dismissAll();
+          refreshNotifications();
+          renderer.requestRender();
+          return;
+        }
+        return;
+      }
+      if (currentOverlay === "share") {
+        if (key.name === "enter" || key.name === "return") {
+          const sel = shareSelect.getSelectedOption();
+          if (sel?.value) {
+            const opt = resultsSelect.getSelectedOption();
+            const repo = opt?.value;
+            if (repo) {
+              const text = formatShare(repo, sel.value);
+              copyToClipboard(text).then((ok) => {
+                showOverlay("none");
+                setStatus(ok ? "\u2713 Copied!" : "Clipboard not available");
+              });
+            }
+          }
+          renderer.requestRender();
+          return;
+        }
+        return;
+      }
+      if (currentOverlay === "help") {
+        showOverlay("none");
+        renderer.requestRender();
+        return;
+      }
+      if (currentOverlay === "update") {
+        if (key.name === "escape" || key.name === "q") {
+          showOverlay("none");
+          renderer.requestRender();
+          return;
+        }
+        if (key.name === "left" || key.name === "h") {
+          updateSelectedOption = Math.max(0, updateSelectedOption - 1);
+          renderUpdateOptions();
+          return;
+        }
+        if (key.name === "right" || key.name === "l") {
+          updateSelectedOption = Math.min(2, updateSelectedOption + 1);
+          renderUpdateOptions();
+          return;
+        }
+        if (key.name === "enter" || key.name === "return") {
+          const action = ["now", "later", "never"][updateSelectedOption];
+          if (action === "now") {
+            showOverlay("none");
+            performUpdate().then((ok) => {
+              if (ok) {
+                setStatus("\u2713 Update complete \u2014 restart ghfind");
+              } else {
+                setStatus("\u2717 Update failed \u2014 check terminal output");
+              }
+            }).catch(() => {
+              setStatus("\u2717 Update failed \u2014 check terminal output");
+            });
+          } else if (action === "never") {
+            suppressUpdateNotices();
+            showOverlay("none");
+            setStatus("Update notices suppressed");
+          } else {
+            snoozeUpdateNotices(3);
+            showOverlay("none");
+            setStatus("Update reminder snoozed for 3 days");
+          }
+          renderer.requestRender();
+          return;
+        }
+        return;
+      }
+      return;
+    }
+    if (key.name === "q") {
+      if (graphFullscreen) {
+        toggleGraph();
+        return;
+      }
+      saveSession({
+        mode: currentMode,
+        query: currentQueryInput,
+        sort: currentSort,
+        limit: currentLimit,
+        trendingTab
+      });
+      cleanup();
+      return;
+    }
+    if (key.name === "escape" && graphFullscreen) {
+      toggleGraph();
+      return;
+    }
+    if (key.name === "space" && !searchInput.focused) {
+      if (currentOverlay === "leader") {
+        showOverlay("none");
+      } else {
+        showLeaderMenu();
+      }
+      return;
+    }
+    if (key.name === "?" || key.name === "h" && key.ctrl) {
+      showOverlay("help");
+      return;
+    }
+    if (key.name === "tab") {
+      if (searchBox.visible) {
+        const val = searchInput.value;
+        const lastSpace = val.lastIndexOf(" ");
+        const currentWord = lastSpace >= 0 ? val.slice(lastSpace + 1) : val;
+        const suggestions = suggestFor(currentWord);
+        if (suggestions.length > 0) {
+          const newVal = lastSpace >= 0 ? val.slice(0, lastSpace + 1) + suggestions[0] : suggestions[0];
+          searchInput.value = newVal;
+          renderer.requestRender();
+        }
+      }
+      return;
+    }
+    if (key.name === "/") {
+      searchInput.focus();
+      showSearchMode();
+      renderer.requestRender();
+      return;
+    }
+    if (/^[1-5]$/.test(key.name)) {
+      if (currentMode === "trending") {
+        const idx = parseInt(key.name) - 1;
+        if (idx >= 0 && idx < TAB_NAMES.length) {
+          trendingTab = TAB_NAMES[idx];
+          loadTrending();
+        }
+      }
+      return;
+    }
+    if (key.name === "left" || key.name === "h") {
+      if (currentMode === "trending") {
+        const idx = TAB_NAMES.indexOf(trendingTab);
+        if (idx > 0) {
+          trendingTab = TAB_NAMES[idx - 1];
+          loadTrending();
+        }
+      }
+      return;
+    }
+    if (key.name === "right" || key.name === "l") {
+      if (currentMode === "trending") {
+        const idx = TAB_NAMES.indexOf(trendingTab);
+        if (idx < TAB_NAMES.length - 1) {
+          trendingTab = TAB_NAMES[idx + 1];
+          loadTrending();
+        }
+      }
+      return;
+    }
+    if (key.name === "pagedown") {
+      if (currentMode === "search" && currentQueryInput) {
+        currentPage++;
+        doSearch(currentQueryInput, true);
+      }
+      return;
+    }
+    if (key.name === "pageup") {
+      if (currentRepos.length > 0) {
+        resultsSelect.setSelectedIndex(0);
+        updateDetail(currentRepos[0]);
+        renderer.requestRender();
+      }
+      return;
+    }
+  });
+  const pkgPath = join2(
+    dirname(fileURLToPath(import.meta.url)),
+    "..",
+    "package.json"
+  );
+  let currentVersion = "0.0.0";
+  try {
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    currentVersion = pkg.version;
+  } catch {
+  }
+  checkForUpdateAndShow();
+  renderer.start();
+  if (currentMode === "trending") {
+    loadTrending();
+  } else {
+    searchInput.value = currentQueryInput;
+    if (currentQueryInput) {
+      doSearch(currentQueryInput);
+    } else {
+      showSearchMode();
+    }
+    searchInput.focus();
+  }
+  renderer.requestRender();
+}
+function formatResultLine(repo) {
+  const stars = formatStars(repo.stars);
+  const lang = (repo.language ?? "?").padEnd(12).slice(0, 12);
+  const name = repo.fullName.padEnd(40).slice(0, 40);
+  return `${name}  ${lang}  ${stars}`;
+}
+function formatStars(n) {
+  if (n >= 1e6) return `\u2605 ${(n / 1e6).toFixed(1).replace(/\.0$/, "")}M`;
+  if (n >= 1e3) return `\u2605 ${(n / 1e3).toFixed(1).replace(/\.0$/, "")}k`;
+  return `\u2605 ${n}`;
+}
+function formatToolbar(sort, limit, totalCount) {
+  const sortLabel = SORT_MODES.find((m) => m.key === sort)?.label ?? sort;
+  return ` sort: ${sortLabel}   limit: ${limit}   results: ${totalCount.toLocaleString()}`;
+}
+function cleanup() {
+  try {
+    rotateHistory();
+  } catch {
+  }
+  process.exit(0);
+}
+if (import.meta.main && false) {
+  launchBrowser();
+}
+
+// src/cli.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var PKG_DIR2 = join3(__dirname2, "..");
+function parseArgs(args) {
+  const flags = {
+    query: "",
+    json: false,
+    csv: false,
+    markdown: false,
+    count: false,
+    limit: 50,
+    sort: "best-match",
+    token: process.env.GITHUB_TOKEN,
+    trending: false,
+    since: "daily",
+    watch: false,
+    interval: 300,
+    init: false,
+    version: false,
+    help: false
+  };
+  let queryParts = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--json":
+        flags.json = true;
+        break;
+      case "--csv":
+        flags.csv = true;
+        break;
+      case "--markdown":
+        flags.markdown = true;
+        break;
+      case "--count":
+        flags.count = true;
+        break;
+      case "--trending":
+        flags.trending = true;
+        break;
+      case "--watch":
+        flags.watch = true;
+        break;
+      case "--version":
+      case "-v":
+        flags.version = true;
+        break;
+      case "--help":
+      case "-h":
+        flags.help = true;
+        break;
+      case "init":
+        flags.init = true;
+        break;
+      case "--limit": {
+        const parsed = parseInt(args[++i]);
+        if (isNaN(parsed) || parsed < 1 || parsed > 100) {
+          console.error(`Invalid limit: must be 1-100. Using default 50.`);
+          flags.limit = 50;
+        } else {
+          flags.limit = parsed;
+        }
+        break;
+      }
+      case "--sort":
+        flags.sort = args[++i];
+        break;
+      case "--token":
+        flags.token = args[++i];
+        break;
+      case "--since":
+        flags.since = args[++i];
+        break;
+      case "--pipe":
+        flags.pipe = args[++i];
+        break;
+      case "--format":
+        flags.format = args[++i];
+        break;
+      case "--interval":
+        flags.interval = parseInt(args[++i]) || 300;
+        break;
+      case "--completion":
+        flags.completion = args[++i];
+        break;
+      default:
+        if (!arg.startsWith("-")) queryParts.push(arg);
+    }
+  }
+  flags.query = queryParts.join(" ");
+  return flags;
+}
+async function main() {
+  const flags = parseArgs(process.argv.slice(2));
+  if (flags.version) {
+    const pkg = JSON.parse(readFileSync3(join3(PKG_DIR2, "package.json"), "utf-8"));
+    console.log(`ghfind v${pkg.version}`);
+    return;
+  }
+  if (flags.help) {
+    console.log(`
+ghfind \u2014 Interactive GitHub repository browser
+
+Usage:
+  ghfind                           Launch interactive TUI
+  ghfind <query> --json            Search, output JSON
+  ghfind <query> --csv             Search, output CSV
+  ghfind <query> --markdown        Search, output Markdown table
+  ghfind <query> --count           Just the result count
+  ghfind <query> --format <fmt>    Format lines (urls|names|ssh-urls|clone-commands|ids)
+  ghfind <query> --pipe <target>   Pipe to clone/open
+  ghfind --trending --json         Trending repos as JSON
+  ghfind --watch <query>           Watch mode (poll every Ns)
+  ghfind init                      Run setup wizard
+  ghfind --completion <shell>      Print completion script (bash|zsh|fish)
+  ghfind --version                 Print version
+  ghfind --help                    Print this help
+
+Options:
+  --json, --csv, --markdown, --count   Output format
+  --limit <n>                          Max results (default: 50)
+  --sort <strategy>                    Sort: best-match|stars|updated|forks
+  --token <token>                      GitHub API token
+  --trending                           Trending mode
+  --since <period>                     Trending period: daily|weekly|monthly
+  --pipe <target>                      Pipe target: clone|open
+  --format <fmt>                       Line format: urls|names|ssh-urls|...
+  --watch                              Watch mode (re-run periodically)
+  --interval <s>                       Watch interval in seconds (default: 300)
+  --completion <shell>                 Generate completions
+`);
+    return;
+  }
+  if (flags.completion) {
+    const shell = flags.completion;
+    try {
+      const content = readFileSync3(join3(PKG_DIR2, "completions", `ghfind.${shell}`), "utf-8");
+      console.log(content);
+    } catch {
+      console.error(`Completions not available for shell: ${shell}`);
+      process.exit(1);
+    }
+    return;
+  }
+  if (flags.init) {
+    await runInitWizard();
+    return;
+  }
+  const outputFormat = flags.json ? "json" : flags.csv ? "csv" : flags.markdown ? "markdown" : void 0;
+  const isNonInteractive = outputFormat || flags.count || flags.format || flags.pipe || flags.watch;
+  if (isNonInteractive) {
+    await runNonInteractive(flags, outputFormat);
+    return;
+  }
+  await launchBrowser();
+}
+function buildSearchContext(flags) {
+  const parsed = applyFlagFilters(parseQuery(flags.query), {});
+  return {
+    query: flags.query,
+    parsed,
+    provider: createGitHubSearch(void 0, flags.token ? [flags.token] : [])
+  };
+}
+async function runNonInteractive(flags, outputFormat) {
+  const handlers = {
+    trending: async (ctx2) => {
+      const since = flags.since === "weekly" ? "weekly" : flags.since === "monthly" ? "monthly" : "daily";
+      const trendingSearch = createTrendingSearch();
+      const response = await trendingSearch.search(
+        { keywords: [], qualifiers: [], raw: "trending" },
+        { limit: 25, sort: "stars", json: false, verbose: false, trendingSince: since }
+      );
+      if (outputFormat) {
+        console.log(format(response.repos, outputFormat));
+      } else if (flags.count) {
+        console.log(response.totalCount);
+      } else {
+        for (const r of response.repos) {
+          console.log(r.fullName + "  \u2605 " + r.stars + "  \u25B2 +" + r.score + " " + since + "  \u25CF " + (r.language ?? ""));
+        }
+      }
+    },
+    watch: async (ctx2) => {
+      let tick = 0;
+      await runWatch(
+        { query: ctx2.query, sort: flags.sort, limit: flags.limit, token: flags.token, intervalMs: flags.interval * 1e3, trending: flags.trending },
+        (repos, delta) => {
+          tick++;
+          if (outputFormat) {
+            console.log(`[Watch #${tick}] ${repos.length} results (${delta >= 0 ? "+" : ""}${delta} since last check)`);
+            console.log(format(repos, outputFormat));
+          } else {
+            console.log(`[Watch #${tick}] ${repos.length} results \u2014 ${delta >= 0 ? "+" : ""}${delta} since last check`);
+          }
+        },
+        (err) => console.error(`[Watch error] ${err.message}`)
+      );
+    },
+    pipe: async (ctx2) => {
+      const response = await ctx2.provider.search(ctx2.parsed, {
+        limit: flags.limit,
+        sort: flags.sort,
+        json: false,
+        verbose: false,
+        token: flags.token
+      });
+      const repos = rankRepos(response.repos, flags.sort);
+      await pipeExec(repos, flags.pipe);
+    },
+    format: async (ctx2) => {
+      const response = await ctx2.provider.search(ctx2.parsed, {
+        limit: flags.limit,
+        sort: flags.sort,
+        json: false,
+        verbose: false,
+        token: flags.token
+      });
+      const repos = rankRepos(response.repos, flags.sort);
+      console.log(format(repos, flags.format));
+    },
+    search: async (ctx2) => {
+      const response = await ctx2.provider.search(ctx2.parsed, {
+        limit: flags.limit,
+        sort: flags.sort,
+        json: false,
+        verbose: false,
+        token: flags.token
+      });
+      const repos = rankRepos(response.repos, flags.sort);
+      if (flags.count) {
+        console.log(response.totalCount);
+        return;
+      }
+      if (outputFormat) {
+        console.log(format(repos, outputFormat));
+      }
+    }
+  };
+  const key = flags.trending && !flags.watch ? "trending" : flags.watch ? "watch" : flags.pipe ? "pipe" : flags.format ? "format" : "search";
+  const ctx = buildSearchContext(flags);
+  await handlers[key](ctx);
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});