github-search-cli 9.8.3 → 9.10.0

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), {});