github-search-cli 0.8.2 → 9.1.0

package/src/types.ts

@@ -57,6 +57,8 @@ export interface SearchOptions {
   token?: string;
   /** Page number for pagination (1-based, default 1). */
   page?: number;
+  /** Trending period: daily|weekly|monthly. Used by TrendingAdapter. */
+  trendingSince?: "daily" | "weekly" | "monthly";
   /** Verbose logging (outgoing query, errors, rate limits). */
   verbose: boolean;
 }

package/src/update-check.ts

@@ -0,0 +1,162 @@
+/**
+ * Update checker — checks npm registry for a newer ghfind version.
+ *
+ * Uses the npm registry HTTP API (no subprocess needed — Bun has native fetch).
+ * Persists check state in the XDG state dir via storage.ts.
+ */
+import { readJSON, writeJSON, debugLog } from "./storage";
+import { stateDir } from "./config";
+
+const REGISTRY_URL = "https://registry.npmjs.org/github-search-cli/latest";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const REQUEST_TIMEOUT_MS = 5000;
+
+export interface UpdateState {
+  /** Timestamp of last successful check. */
+  lastCheck: number;
+  /** Timestamp until which we should suppress the panel (snooze). */
+  snoozeUntil: number;
+  /** If true, never show the update panel again. */
+  suppressed: boolean;
+  /** Latest version found on last check (for display). */
+  latestVersion?: string;
+}
+
+const STATE_FILE = "update-state.json";
+export const DEFAULTS: UpdateState = {
+  lastCheck: 0,
+  snoozeUntil: 0,
+  suppressed: false,
+};
+
+/** Read update-check state from disk. */
+export function readUpdateState(): UpdateState {
+  return { ...DEFAULTS, ...readJSON<Partial<UpdateState>>(STATE_FILE, {}) };
+}
+
+/** Write update-check state to disk. */
+export function writeUpdateState(state: UpdateState): void {
+  writeJSON(STATE_FILE, state);
+}
+
+/**
+ * Whether we should run an update check now, based on cached state.
+ * Returns false if: suppressed, snoozed, or checked within the last 24h.
+ */
+export function shouldCheckUpdate(): boolean {
+  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;
+}
+
+/**
+ * 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.
+ */
+export function isNewerVersion(current: string, latest: string): boolean {
+  // ponytail: Bun.semver.order is the right tool — native, correct on edge cases
+  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]));
+  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;
+}
+
+/**
+ * Check the npm registry for a newer version of ghfind.
+ * Returns the latest version string if an update is available, or null.
+ * Never throws — failures (offline, timeout, DNS) return null silently.
+ */
+export async function checkForUpdate(
+  currentVersion: string,
+): Promise<string | null> {
+  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() as { version?: string };
+    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;
+  }
+}
+
+/**
+ * Mark the update check as done. Stores the latest version if one was found.
+ */
+export function markUpdateChecked(latestVersion?: string): void {
+  writeUpdateState({
+    ...readUpdateState(),
+    lastCheck: Date.now(),
+    latestVersion,
+  });
+}
+
+/**
+ * Snooze update notifications for the given number of days.
+ */
+export function snoozeUpdateNotices(days: number): void {
+  writeUpdateState({
+    ...readUpdateState(),
+    snoozeUntil: Date.now() + days * 24 * 60 * 60 * 1000,
+  });
+}
+
+/**
+ * Permanently suppress the update panel.
+ */
+export function suppressUpdateNotices(): void {
+  writeUpdateState({
+    ...readUpdateState(),
+    suppressed: true,
+  });
+}
+
+/**
+ * Attempt to update ghfind in-place.
+ * Uses `process.versions.bun` for reliable runtime detection (works on all platforms).
+ */
+export async function performUpdate(): Promise<boolean> {
+  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;
+  }
+}

package/src/watch.ts

@@ -4,6 +4,7 @@
  */
 import type { ParsedQuery, SearchOptions, Repo } from "./types";
 import { parseQuery, applyFlagFilters, rankRepos, createGitHubSearch } from "./search";
+import { createTrendingSearch } from "./search";
 
 export interface WatchOptions {
   query: string;
@@ -28,17 +29,28 @@ export async function runWatch(
 
   const tick = async () => {
     try {
-      const parsed = applyFlagFilters(parseQuery(opts.query), {});
-      const provider = createGitHubSearch(undefined, opts.token ? [opts.token] : []);
-      const options: SearchOptions = {
-        limit: opts.limit,
-        sort: opts.sort,
-        json: false,
-        verbose: false,
-        token: opts.token,
-      };
-      const response = await provider.search(parsed, options);
-      const repos = rankRepos(response.repos, options.sort);
+      let repos: Repo[];
+      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(undefined, opts.token ? [opts.token] : []);
+        const options: SearchOptions = {
+          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; // reset on success
       const delta = previous.length > 0 ? repos.length - previous.length : 0;