github-search-cli 0.8.2 → 9.1.0

package/src/output.ts

@@ -1,68 +1,137 @@
-/** Output layer: render ranked results as JSON or human-readable list. */
-import type { Repo, SearchResponse } from "./types";
-
-/** Format a number compactly (e.g. 1234 -> "1.2k", 999999 -> "1M"). */
-export function formatCount(n: number): string {
-  if (n < 1000) return String(n);
-  if (n >= 999_500) return "1M"; // ponytail: round 999500+ up before showing 1000k
-  if (n < 1_000_000) return `${(n / 1000).toFixed(1).replace(/\.0$/, "")}k`;
-  return `${(n / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;
+/**
+ * Output module — unified formatting, export, and pipe execution.
+ *
+ * All format functions (JSON, CSV, Markdown, text, urls, names, ssh-urls,
+ * clone-commands, ids) register in a single registry. One `format()` function
+ * dispatches. `exportToFile` and `pipeExec` are methods on the same module.
+ */
+import { writeFileSync } from "fs";
+import type { Repo } from "./types";
+import { openUrl } from "./open-url";
+
+export type Format =
+  | "json" | "csv" | "markdown" | "text"
+  | "urls" | "names" | "ssh-urls" | "clone-commands" | "ids";
+
+export type FormatFn = (repos: Repo[]) => string;
+
+/** Registry of all format functions. Adding a format = 1 line here. */
+const FORMATS: Map<Format, FormatFn> = 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],
+]);
+
+// ── Export format functions ────────────────────────────────────────────
+
+export function formatJson(repos: Repo[]): string {
+  return JSON.stringify(repos, null, 2);
 }
 
-export function formatDate(iso: string): string {
-  const d = new Date(iso);
-  if (isNaN(d.getTime())) return "unknown";
-  return d.toISOString().slice(0, 10);
+function csvEscape(val: unknown): string {
+  const str = String(val ?? "");
+  if (str.includes('"') || str.includes(",") || str.includes("\n")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
 }
 
-export function renderJson(response: SearchResponse, rawQuery: string): string {
-  return JSON.stringify(
-    {
-      query: rawQuery,
-      totalCount: response.totalCount,
-      count: response.repos.length,
-      rateLimited: response.rateLimited,
-      results: response.repos,
-    },
-    null,
-    2,
+export function formatCsv(repos: Repo[]): string {
+  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");
 }
 
-export function renderHuman(response: SearchResponse, rawQuery: string): string {
-  const lines: string[] = [];
-  lines.push(`Query: ${rawQuery}`);
-  lines.push(`Matches: ${response.repos.length} (total available: ${response.totalCount})`);
-  if (response.rateLimited) {
-    lines.push("⚠ Rate limit hit — results may be incomplete. Set GITHUB_TOKEN to raise limits.");
-  }
-  lines.push("");
+export function formatMarkdown(repos: Repo[]): string {
+  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 ?? "—"} |`,
+  );
+  return [header, sep, ...rows].join("\n");
+}
+
+export function formatText(repos: Repo[]): string {
+  return repos.map((r, i) => `${i + 1}. ${r.fullName} ★ ${r.stars.toLocaleString()} ${r.url}`).join("\n");
+}
+
+// ── Pipe format functions ──────────────────────────────────────────────
+
+export function formatUrls(repos: Repo[]): string {
+  return repos.map((r) => r.url).join("\n");
+}
+
+export function formatNames(repos: Repo[]): string {
+  return repos.map((r) => r.fullName).join("\n");
+}
+
+export function formatSshUrls(repos: Repo[]): string {
+  return repos.map((r) => `git@github.com:${r.fullName}.git`).join("\n");
+}
+
+export function formatCloneCommands(repos: Repo[]): string {
+  return repos.map((r) => `git clone git@github.com:${r.fullName}.git`).join("\n");
+}
+
+export function formatIds(repos: Repo[]): string {
+  return repos.map((r) => String(r.id)).join("\n");
+}
+
+// ── Public API ─────────────────────────────────────────────────────────
 
-  if (response.repos.length === 0) {
-    lines.push("No repositories found.");
-    return lines.join("\n");
+/** Format repos using the registered format function. */
+export function format(repos: Repo[], format: Format): string {
+  const fn = FORMATS.get(format);
+  if (!fn) throw new Error(`Unknown format: ${format}`);
+  return fn(repos);
+}
+
+/** Export repos to a file. Returns the file path. */
+export function exportToFile(repos: Repo[], fmt: Format): string {
+  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;
+}
+
+/** Execute a pipe target (clone, open) on repos. */
+export async function pipeExec(repos: Repo[], target: string): Promise<void> {
+  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;
+    }
   }
+}
+
+// ─── Backward-compatible re-exports ─────────────────────────────────────
 
-  response.repos.forEach((repo, i) => {
-    lines.push(renderRepo(i + 1, repo));
-    lines.push("");
-  });
+export type ExportFormat = "json" | "csv" | "markdown" | "text";
+export type FormatLine = "urls" | "names" | "ssh-urls" | "clone-commands" | "ids";
 
-  return lines.join("\n").trimEnd();
+/** @deprecated Use `format()` instead. */
+export function formatRepos(repos: Repo[], fmt: ExportFormat): string {
+  return format(repos, fmt);
 }
 
-function renderRepo(index: number, repo: Repo): string {
-  const lang = repo.language ?? "—";
-  const stars = formatCount(repo.stars);
-  const updated = formatDate(repo.updatedAt);
-  const tags: string[] = [];
-  if (repo.archived) tags.push("archived");
-  if (repo.isFork) tags.push("fork");
-  const tagStr = tags.length ? ` [${tags.join(", ")}]` : "";
-
-  const header = `${index}. ${repo.fullName}${tagStr}`;
-  const meta = `   ★ ${stars}  •  ${lang}  •  updated ${updated}`;
-  const desc = repo.description ? `   ${repo.description}` : "   (no description)";
-  const url = `   ${repo.url}`;
-  return [header, meta, desc, url].join("\n");
-}
+/** @deprecated Use `format()` instead. */
+export function formatLines(repos: Repo[], fmt: FormatLine): string {
+  return format(repos, fmt);
+}

package/src/saved-searches.ts

@@ -1,25 +1,17 @@
 /**
  * Saved searches — named queries you can re-run anytime.
  */
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
 import type { SavedSearch, SortStrategy } from "./types";
-import { stateDir } from "./config";
+import { readJSON, writeJSON } from "./storage";
 
-const SAVED_FILE = join(stateDir(), "saved-searches.json");
+const SAVED_FILE = "saved-searches.json";
 
 function loadRaw(): SavedSearch[] {
-  mkdirSync(stateDir(), { recursive: true });
-  try {
-    return JSON.parse(readFileSync(SAVED_FILE, "utf-8")) as SavedSearch[];
-  } catch {
-    return [];
-  }
+  return readJSON<SavedSearch[]>(SAVED_FILE, []);
 }
 
 function saveRaw(searches: SavedSearch[]): void {
-  mkdirSync(stateDir(), { recursive: true });
-  writeFileSync(SAVED_FILE, JSON.stringify(searches, null, 2));
+  writeJSON(SAVED_FILE, searches);
 }
 
 /** Get all saved searches, sorted by last run time (most recent first). */

package/src/search-state.ts

@@ -0,0 +1,229 @@
+/**
+ * SearchState — owns all TUI state and domain calls.
+ *
+ * The TUI view layer reads from SearchState and dispatches actions.
+ * This module is testable without the OpenTUI renderer.
+ */
+import type { Repo, SearchOptions, SortStrategy, SessionState } from "./types";
+import type { TabName } from "./trending";
+import { tabSince } from "./trending";
+import { parseQuery, applyFlagFilters, rankRepos, createGitHubSearch, SearchModule, TrendingAdapter } from "./search";
+import { restoreSession, saveSession } from "./session";
+import { appendHistory } from "./history";
+import { toggleBookmark, isBookmarked } from "./bookmarks";
+import { saveSearch, getSavedSearches, touchSavedSearch } from "./saved-searches";
+import { fetchDeepDive, buildDeepDiveText } from "./deepdive";
+import { fetchTopics } from "./explore";
+import { loadConfig } from "./config";
+
+export type Overlay =
+  | "none" | "history" | "bookmarks" | "saved" | "help"
+  | "topics" | "export" | "compare" | "notifications"
+  | "share" | "leader" | "readme";
+
+export interface SearchState {
+  // Core search state
+  currentRepos: Repo[];
+  currentSort: SortStrategy;
+  currentLimit: number;
+  currentQueryInput: string;
+  isLoading: boolean;
+  currentMode: "search" | "trending";
+  currentPage: number;
+  totalCount: number;
+
+  // Trending
+  trendingTab: TabName;
+  trendingPeriod: string;
+
+  // UI overlays
+  currentOverlay: Overlay;
+  deepDiveActive: boolean;
+  compareList: Repo[];
+  graphFullscreen: boolean;
+  chartCommitData: number[];
+  quitArmed: boolean;
+}
+
+export class SearchStateManager {
+  private config = loadConfig();
+  private provider = createGitHubSearch(undefined, this.config.githubTokens);
+  private trendingSearch = new SearchModule(new TrendingAdapter());
+
+  state: SearchState = {
+    currentRepos: [],
+    currentSort: this.config.defaultSort,
+    currentLimit: this.config.defaultLimit,
+    currentQueryInput: "",
+    isLoading: false,
+    currentMode: "search",
+    currentPage: 1,
+    totalCount: 0,
+    trendingTab: "This Week",
+    trendingPeriod: "this week",
+    currentOverlay: "none",
+    deepDiveActive: false,
+    compareList: [],
+    graphFullscreen: false,
+    chartCommitData: [],
+    quitArmed: false,
+  };
+
+  constructor() {
+    const session = restoreSession();
+    if (session) {
+      this.state.currentMode = session.mode;
+      this.state.currentQueryInput = session.query;
+      this.state.currentSort = session.sort;
+      this.state.currentLimit = session.limit;
+      this.state.trendingTab = (session.trendingTab as TabName) ?? "This Week";
+    }
+  }
+
+  // ── Search ──
+
+  async search(query: string, page: number = 1): Promise<void> {
+    this.state.isLoading = true;
+    this.state.currentQueryInput = query;
+    this.state.currentPage = page;
+    try {
+      const parsed = applyFlagFilters(parseQuery(query), {});
+      const response = await this.provider.search(parsed, {
+        limit: this.state.currentLimit,
+        sort: this.state.currentSort,
+        json: false,
+        verbose: false,
+        token: this.config.githubToken,
+        page,
+      });
+      this.state.currentRepos = rankRepos(response.repos, this.state.currentSort);
+      this.state.totalCount = response.totalCount;
+      this.state.currentMode = "search";
+      appendHistory({ query, mode: "search", timestamp: Date.now(), resultCount: response.repos.length });
+    } catch (err) {
+      throw err;
+    } finally {
+      this.state.isLoading = false;
+    }
+  }
+
+  async nextPage(): Promise<void> {
+    await this.search(this.state.currentQueryInput, this.state.currentPage + 1);
+  }
+
+  async prevPage(): Promise<void> {
+    if (this.state.currentPage > 1) {
+      await this.search(this.state.currentQueryInput, this.state.currentPage - 1);
+    }
+  }
+
+  // ── Trending ──
+
+  async loadTrending(tab: TabName): Promise<void> {
+    this.state.isLoading = true;
+    this.state.trendingTab = tab;
+    this.state.currentMode = "trending";
+    try {
+      const response = await this.trendingSearch.search(
+        { keywords: [], qualifiers: [], raw: "trending" },
+        { limit: 25, sort: "stars", json: false, verbose: false, trendingSince: tabSince(tab) },
+      );
+      this.state.currentRepos = response.repos;
+      this.state.totalCount = response.totalCount;
+      appendHistory({ query: `trending:${tab}`, mode: "trending", tab, timestamp: Date.now(), resultCount: response.repos.length });
+    } finally {
+      this.state.isLoading = false;
+    }
+  }
+
+  // ── Bookmarks ──
+
+  toggleBookmark(repo: Repo): boolean {
+    return toggleBookmark(repo);
+  }
+
+  isBookmarked(fullName: string): boolean {
+    return isBookmarked(fullName);
+  }
+
+  // ── Saved searches ──
+
+  saveCurrentSearch(name: string): void {
+    saveSearch(name, this.state.currentQueryInput, this.state.currentMode, this.state.currentSort, this.state.currentLimit);
+  }
+
+  getSavedSearches() {
+    return getSavedSearches();
+  }
+
+  touchSavedSearch(name: string): void {
+    touchSavedSearch(name);
+  }
+
+  // ── Deep dive ──
+
+  async deepDive(repo: Repo): Promise<string> {
+    this.state.deepDiveActive = true;
+    try {
+      const data = await fetchDeepDive(repo, this.config.githubToken);
+      return buildDeepDiveText(data);
+    } finally {
+      this.state.deepDiveActive = false;
+    }
+  }
+
+  // ── Compare ──
+
+  addToCompare(repo: Repo): void {
+    if (!this.state.compareList.some((r) => r.fullName === repo.fullName)) {
+      this.state.compareList.push(repo);
+    }
+  }
+
+  removeFromCompare(fullName: string): void {
+    this.state.compareList = this.state.compareList.filter((r) => r.fullName !== fullName);
+  }
+
+  clearCompare(): void {
+    this.state.compareList = [];
+  }
+
+  // ── Session ──
+
+  saveSession(): void {
+    const s: SessionState = {
+      mode: this.state.currentMode,
+      query: this.state.currentQueryInput,
+      sort: this.state.currentSort,
+      limit: this.state.currentLimit,
+      trendingTab: this.state.trendingTab,
+    };
+    saveSession(s);
+  }
+
+  // ── Setters ──
+
+  setSort(sort: SortStrategy): void {
+    this.state.currentSort = sort;
+  }
+
+  setLimit(limit: number): void {
+    this.state.currentLimit = limit;
+  }
+
+  setOverlay(overlay: Overlay): void {
+    this.state.currentOverlay = overlay;
+  }
+
+  setGraphFullscreen(fullscreen: boolean): void {
+    this.state.graphFullscreen = fullscreen;
+  }
+
+  setChartCommitData(data: number[]): void {
+    this.state.chartCommitData = data;
+  }
+
+  setQuitArmed(armed: boolean): void {
+    this.state.quitArmed = armed;
+  }
+}

package/src/search.ts

@@ -467,6 +467,96 @@ function appendPage(url: string, page: number, perPage: number): string {
   return u.toString();
 }
 
+// ─── Trending adapter ─────────────────────────────────────────────────
+
+const TRENDING_URL = "https://github.com/trending";
+
+interface RawTrendingRepo {
+  rank: number;
+  owner: string;
+  name: string;
+  stars: number;
+  starsToday: number;
+  language: string;
+  description: string;
+}
+
+function parseTrendingHtml(html: string): RawTrendingRepo[] {
+  const flat = html.replace(/>\s+</g, "><").replace(/\s+/g, " ");
+  const repos: RawTrendingRepo[] = [];
+  const articleRe = /<article class="Box-row">(.*?)<\/article>/gi;
+  let match: RegExpExecArray | null;
+  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: RawTrendingRepo): Repo {
+  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,
+  };
+}
+
+/**
+ * Trending adapter — scrapes github.com/trending HTML and returns SearchResponse.
+ */
+export class TrendingAdapter implements SearchAdapter {
+  readonly name = "trending";
+  private readonly logger: Logger;
+
+  constructor(logger: Logger = noopLogger) {
+    this.logger = logger;
+  }
+
+  async search(_query: ParsedQuery, options: SearchOptions): Promise<SearchResponse> {
+    const since = options.trendingSince ?? "daily";
+    const url = since === "daily" ? TRENDING_URL : `${TRENDING_URL}?since=${since}`;
+    let res: Response;
+    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 };
+  }
+}
+
 // ─── In-memory adapter (for tests) ────────────────────────────────────
 
 /**
@@ -551,5 +641,12 @@ export function createGitHubSearch(
   return new SearchModule(new GitHubSearchAdapter(logger, tokens), logger);
 }
 
-// Re-export types that callers need
-export type { GitHubApiItem, GitHubSearchEnvelope };
+/**
+ * Create a SearchModule backed by the Trending adapter.
+ */
+export function createTrendingSearch(
+  logger: Logger = noopLogger,
+): SearchModule {
+  return new SearchModule(new TrendingAdapter(logger), logger);
+}
+

package/src/session.ts

@@ -1,17 +1,14 @@
 /**
  * Session restore — save/restore UI state between restarts.
  */
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import type { SessionState, SortStrategy } from "./types";
-import { stateDir } from "./config";
+import type { SessionState } from "./types";
+import { readJSON, writeJSON } from "./storage";
 
-const SESSION_FILE = join(stateDir(), "session.json");
+const SESSION_FILE = "session.json";
 
 export function saveSession(state: SessionState): void {
-  mkdirSync(stateDir(), { recursive: true });
   try {
-    writeFileSync(SESSION_FILE, JSON.stringify(state));
+    writeJSON(SESSION_FILE, state);
   } catch (err) {
     if (process.env.DEBUG)
       console.error(`[ghfind] Failed to save session: ${err instanceof Error ? err.message : String(err)}`);
@@ -19,18 +16,9 @@ export function saveSession(state: SessionState): void {
 }
 
 export function restoreSession(): SessionState | null {
-  try {
-    const raw = readFileSync(SESSION_FILE, "utf-8");
-    return JSON.parse(raw) as SessionState;
-  } catch {
-    return null;
-  }
+  return readJSON<SessionState | null>(SESSION_FILE, null);
 }
 
 export function clearSession(): void {
-  try {
-    writeFileSync(SESSION_FILE, "");
-  } catch {
-    // non-critical
-  }
+  writeJSON(SESSION_FILE, null);
 }