github-search-cli 9.8.3 → 9.9.0

package/src/trending.ts

@@ -14,7 +14,7 @@ import {
 import type { CliRenderer } from "@opentui/core";
 import type { Repo, ParsedQuery } from "./types";
 import { openUrl } from "./open-url";
-import { SearchModule, TrendingAdapter } from "./search";
+import { SearchModule, TrendingAdapter, trendingQuery } from "./search";
 import { detectTerminalBackground, deriveSurfaceLayers } from "./themes";
 // ─── Tokyo Night palette ──────────────────────────────────────────────
 const C = {
@@ -207,11 +207,7 @@ export async function launchTrending(): Promise<void> {
     renderer.requestRender();
     try {
       const searchModule = new SearchModule(new TrendingAdapter());
-      const parsed: ParsedQuery = {
-        keywords: [],
-        qualifiers: [],
-        raw: "trending",
-      };
+      const parsed: ParsedQuery = trendingQuery();
       const response = await searchModule.search(parsed, {
         limit: 25,
         sort: "stars",

package/src/tui.ts

@@ -31,6 +31,7 @@ import {
   SelectRenderable,
   ScrollBoxRenderable,
 } from "@opentui/core";
+import { appendFileSync } from "node:fs";
 import type { CliRenderer } from "@opentui/core";
 import type {
   Repo,
@@ -47,6 +48,8 @@ import {
   applyFlagFilters,
   validateQuery,
   suggestFor,
+  suggestRelaxations,
+  trendingQuery,
   rankRepos,
   createGitHubSearch,
   SearchModule,
@@ -120,6 +123,7 @@ import {
   fetchReleaseNotes,
   readUpdateState,
   recordPreUpdateState,
+  markPostUpgradeSeen,
 } from "./update-check";
 import { debugLog } from "./storage";
 import {
@@ -152,12 +156,41 @@ const colors: Record<string, string> = {
 };
 
 // ─── Logger ───────────────────────────────────────────────────────────
-const logger: Logger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-};
+/**
+ * TUI diagnostic log.
+ *
+ * The TUI owns the screen, so it cannot print debug output to stdout without
+ * corrupting the render — and the logger used to be a silent no-op, which made
+ * API failures (403/401) undiagnosable from the status-bar message alone.
+ *
+ * Set GHFIND_LOG=<path> to append timestamped lines to that file. Unset (the
+ * default) keeps logging completely off, so there is no cost in normal use.
+ * Only the shape of a response is recorded; tokens and headers are redacted.
+ */
+function createTuiLogger(): Logger {
+  const target = process.env.GHFIND_LOG;
+  if (!target) {
+    return { debug: () => {}, info: () => {}, warn: () => {}, error: () => {} };
+  }
+  const write = (level: string, msg: string) => {
+    try {
+      appendFileSync(
+        target,
+        `[${new Date().toISOString()}] [${level}] ${msg}\n`,
+      );
+    } catch {
+      // A broken log path must never take down the TUI.
+    }
+  };
+  return {
+    debug: (m) => write("debug", m),
+    info: (m) => write("info", m),
+    warn: (m) => write("warn", m),
+    error: (m) => write("error", m),
+  };
+}
+
+const logger: Logger = createTuiLogger();
 
 // ─── Sort cycle ───────────────────────────────────────────────────────
 const SORT_MODES: { key: SortStrategy; label: string }[] = [
@@ -1625,6 +1658,9 @@ export async function launchBrowser(theme_override?: string): Promise<void> {
     if (state.lastInstalledVersion === currentVersion) return;
     // We just upgraded — show notes for the new version
     const notes = fetchReleaseNotes(currentVersion);
+    // Acknowledge immediately: this panel's trigger is a version inequality,
+    // so leaving it unacknowledged makes it reappear on every launch.
+    markPostUpgradeSeen(currentVersion);
     updateSelectedOption = 0;
     updateHeader.content = `  Updated ghfind ${state.lastInstalledVersion} → ${currentVersion}\n`;
     updateNotes.setContent(
@@ -2365,16 +2401,13 @@ export async function launchBrowser(theme_override?: string): Promise<void> {
 
     try {
       const searchModule = new SearchModule(new TrendingAdapter());
-      const response = await searchModule.search(
-        { keywords: [], qualifiers: [], raw: "trending" },
-        {
-          limit: 25,
-          sort: "stars",
-          json: false,
-          verbose: false,
-          trendingSince: tabSince(trendingTab),
-        },
-      );
+      const response = await searchModule.search(trendingQuery(), {
+        limit: 25,
+        sort: "stars",
+        json: false,
+        verbose: false,
+        trendingSince: tabSince(trendingTab),
+      });
       const fetched = response.repos;
       const since = tabSince(trendingTab);
       trendingPeriod =
@@ -2528,7 +2561,12 @@ export async function launchBrowser(theme_override?: string): Promise<void> {
       }
 
       if (currentRepos.length === 0) {
-        throw new NoResultsError(q);
+        // A zero-result search usually means one qualifier over-constrained
+        // it. Offer the ranked loosenings instead of generic advice.
+        throw new NoResultsError(
+          q,
+          suggestRelaxations(parsed).map((r) => r.suggestion),
+        );
       } else {
         resultsSelect.options = currentRepos.map((r) => ({
           name: formatResultLine(r),

package/src/types.ts

@@ -10,14 +10,24 @@ export interface Qualifier {
   negated: boolean;
 }
 
+/** A normalization applied to a qualifier while parsing (typo fix, `10k` → `>=10000`). */
+export interface QueryCorrection {
+  /** What the user typed, e.g. `langauge:rust`. */
+  from: string;
+  /** What it was normalized to, e.g. `language:Rust`. */
+  to: string;
+}
+
 /** The fully parsed, normalized representation of a user's search request. */
 export interface ParsedQuery {
   /** Free-text keywords (everything that is not a qualifier). */
   keywords: string[];
-  /** Structured qualifiers extracted from the query string. */
+  /** Structured qualifiers extracted from the query string, normalized. */
   qualifiers: Qualifier[];
   /** The original, untouched query string (preserved for debugging/display). */
   raw: string;
+  /** Normalizations applied while parsing. Empty when the query was already canonical. */
+  corrections: QueryCorrection[];
 }
 
 /** A repository as returned by a search provider, normalized to a stable shape. */

package/src/update-check.ts

@@ -59,6 +59,32 @@ export function shouldCheckUpdate(): boolean {
   return true;
 }
 
+/**
+ * Split a semver string into comparable numeric parts.
+ *
+ * A leading `v` is tolerated. Pre-release (`-beta.1`) and build (`+build.5`)
+ * suffixes are both stripped first, so `9.9.0+build.5` and `9.9.0` compare as
+ * the same release — leaving them in makes `Number("0+build")` NaN.
+ */
+function semverParts(v: string): number[] {
+  const core = v.trim().replace(/^v/i, "").split(/[-+]/)[0];
+  return core.split(".").map((s) => {
+    const n = Number(s);
+    return Number.isFinite(n) ? n : 0;
+  });
+}
+
+/**
+ * True when `v` carries a pre-release tag (`-beta.1`, `-rc.2`, …).
+ * npm semantics: a pre-release is OLDER than the matching release.
+ */
+function isPrerelease(v: string): boolean {
+  const core = v.trim().replace(/^v/i, "");
+  const plus = core.indexOf("+");
+  const coreOnly = plus === -1 ? core : core.slice(0, plus);
+  return coreOnly.includes("-");
+}
+
 /**
  * Compare two semver strings. Returns true if `latest` is newer than `current`.
  * Uses Bun's built-in semver if available, falls back to simple comparison.
@@ -68,16 +94,27 @@ export function isNewerVersion(current: string, latest: string): boolean {
   if (typeof Bun !== "undefined" && Bun.semver) {
     return Bun.semver.order(current, latest) < 0;
   }
-  // Fallback: naive string comparison (works for simple semver; does not handle pre-release tags)
-  const curParts = current.split(".").map((s) => Number(s.split("-")[0]));
-  const newParts = latest.split(".").map((s) => Number(s.split("-")[0]));
+  // Fallback for Node/compiled binaries. npm orders `1.0.0-beta.1` BEFORE
+  // `1.0.0`, so a prerelease only counts as an upgrade when its numeric core
+  // is genuinely ahead — never for the same core, which would be a downgrade.
+  const curParts = semverParts(current);
+  const newParts = semverParts(latest);
+  let order = 0;
   for (let i = 0; i < Math.max(curParts.length, newParts.length); i++) {
     const c = curParts[i] ?? 0;
     const n = newParts[i] ?? 0;
-    if (n > c) return true;
-    if (n < c) return false;
+    if (n > c) {
+      order = 1;
+      break;
+    }
+    if (n < c) {
+      order = -1;
+      break;
+    }
   }
-  return false;
+  if (order !== 0) return order > 0;
+  // Same numeric core: only a prerelease -> release move is an upgrade.
+  return isPrerelease(current) && !isPrerelease(latest);
 }
 
 /**
@@ -257,6 +294,35 @@ export function recordPreUpdateState(currentVersion: string): void {
   });
 }
 
+/**
+ * Acknowledge that the post-upgrade panel for `shownVersion` has been seen.
+ *
+ * The panel's trigger is `lastInstalledVersion !== currentVersion`, so without
+ * this write the state stays "upgraded" forever and the panel reappears on
+ * every single launch — including after the user dismissed it with "later" or
+ * "never", since neither touches `lastInstalledVersion`. Writing the running
+ * version makes the condition false exactly once.
+ *
+ * Best-effort: a failed write must not block the panel from being shown.
+ */
+export function markPostUpgradeSeen(currentVersion: string): void {
+  try {
+    const state = readUpdateState();
+    // Already acknowledged — nothing to do.
+    if (state.lastInstalledVersion === currentVersion) return;
+    // Only acknowledge a recorded version that is genuinely OLDER than the
+    // running one (the upgrade we just showed notes for). If the recorded
+    // version is NEWER — e.g. an update landed mid-session, or the install was
+    // rolled back — leave it alone so the next launch still reports something.
+    if (isNewerVersion(currentVersion, state.lastInstalledVersion ?? "")) {
+      return;
+    }
+    writeUpdateState({ ...state, lastInstalledVersion: currentVersion });
+  } catch {
+    // non-critical
+  }
+}
+
 /**
  * Fetch release notes for a given version.
  * Tries release-notes/<version>.md first, then falls back to CHANGELOG.md section.

package/src/watch.ts

@@ -8,8 +8,9 @@ import {
   applyFlagFilters,
   rankRepos,
   createGitHubSearch,
+  validateQuery,
 } from "./search";
-import { createTrendingSearch } from "./search";
+import { createTrendingSearch, trendingQuery } from "./search";
 
 export interface WatchOptions {
   query: string;
@@ -32,6 +33,13 @@ export async function runWatch(
   let failCount = 0;
   let intervalId: ReturnType<typeof setInterval> | null = null;
 
+  // Validate once, before the poll loop starts. A malformed query is not
+  // transient, so letting it reach the tick would burn the retry budget and
+  // report the same error five times instead of failing fast.
+  if (!opts.trending) {
+    validateQuery(applyFlagFilters(parseQuery(opts.query), {}));
+  }
+
   const tick = async () => {
     try {
       let repos: Repo[];
@@ -43,16 +51,13 @@ export async function runWatch(
               ? "monthly"
               : "daily";
         const trendingSearch = createTrendingSearch();
-        const response = await trendingSearch.search(
-          { keywords: [], qualifiers: [], raw: "trending" },
-          {
-            limit: opts.limit,
-            sort: opts.sort,
-            json: false,
-            verbose: false,
-            trendingSince: since,
-          },
-        );
+        const response = await trendingSearch.search(trendingQuery(), {
+          limit: opts.limit,
+          sort: opts.sort,
+          json: false,
+          verbose: false,
+          trendingSince: since,
+        });
         repos = response.repos;
       } else {
         const parsed = applyFlagFilters(parseQuery(opts.query), {});