github-search-cli 0.8.1 → 0.9.0

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

package/src/storage.ts

@@ -0,0 +1,106 @@
+/**
+ * Storage adapter — single point of file I/O for state files.
+ *
+ * All domain modules (history, bookmarks, saved-searches, notifications,
+ * session, config) delegate file I/O here. Swap for an in-memory
+ * implementation in tests.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { stateDir } from "./config";
+
+/** Ensure the state directory exists. */
+function ensureDir(): void {
+  mkdirSync(stateDir(), { recursive: true });
+}
+
+/** Read and parse a JSON file. Returns `fallback` on any error. */
+export function readJSON<T>(filename: string, fallback: T): T {
+  ensureDir();
+  try {
+    return JSON.parse(readFileSync(join(stateDir(), filename), "utf-8")) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+/** Write data as JSON to a file. */
+export function writeJSON(filename: string, data: unknown): void {
+  ensureDir();
+  writeFileSync(join(stateDir(), filename), JSON.stringify(data, null, 2));
+}
+
+/** Append one JSON object as a line to a JSONL file. */
+export function appendJSONL(filename: string, obj: unknown): void {
+  ensureDir();
+  try {
+    appendFileSync(join(stateDir(), filename), JSON.stringify(obj) + "\n", "utf-8");
+  } catch {
+    // non-critical
+  }
+}
+
+/** Read all lines from a JSONL file, parsing each as JSON. */
+export function readJSONL<T>(filename: string): T[] {
+  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) as T);
+  } catch {
+    return [];
+  }
+}
+
+/** Write raw text to a file (bypasses JSON encoding). */
+export function writeRaw(filename: string, data: string): void {
+  ensureDir();
+  writeFileSync(join(stateDir(), filename), data);
+}
+
+/** Delete a file if it exists. */
+export function deleteFile(filename: string): void {
+  try {
+    unlinkSync(join(stateDir(), filename));
+  } catch {
+    // non-critical
+  }
+}
+
+/** Append a timestamped debug line to ghfind-debug.log (only when DEBUG is set). */
+export function debugLog(msg: string): void {
+  if (!process.env.DEBUG) return;
+  try {
+    appendFileSync(join(stateDir(), "ghfind-debug.log"), `[${new Date().toISOString()}] ${msg}\n`, "utf-8");
+  } catch { /* ignore */ }
+}
+
+/** Check if a file exists in the state dir. */
+export function fileExists(filename: string): boolean {
+  return existsSync(join(stateDir(), filename));
+}
+
+// ─── In-memory implementation for tests ────────────────────────────────
+
+const memStore = new Map<string, string>();
+
+export const memoryStorage = {
+  readJSON<T>(filename: string, fallback: T): T {
+    const raw = memStore.get(filename);
+    if (!raw) return fallback;
+    try { return JSON.parse(raw) as T; } catch { return fallback; }
+  },
+  writeJSON(filename: string, data: unknown): void {
+    memStore.set(filename, JSON.stringify(data, null, 2));
+  },
+  appendJSONL(filename: string, obj: unknown): void {
+    const existing = memStore.get(filename) ?? "";
+    memStore.set(filename, existing + JSON.stringify(obj) + "\n");
+  },
+  readJSONL<T>(filename: string): T[] {
+    const raw = memStore.get(filename);
+    if (!raw) return [];
+    return raw.trim().split("\n").filter(Boolean).map((l) => JSON.parse(l) as T);
+  },
+  clear(): void { memStore.clear(); },
+};

package/src/themes.ts

@@ -1,12 +1,20 @@
 /**
- * Theme system — 3 built-in palettes. Apply theme to TUI colors.
+ * Theme system — Premium palettes with nuanced color layers.
+ * Each theme provides a rich color hierarchy for premium visual depth.
  */
 export interface Theme {
   name: string;
+  /** Primary background — deepest layer */
   bg: string;
+  /** Secondary surface — cards, panels, elevated areas */
   surface: string;
+  /** Tertiary surface — subtle hover/focus states */
+  surfaceAlt: string;
+  /** Primary text — highest contrast */
   text: string;
+  /** Secondary text — labels, metadata */
   muted: string;
+  /** Accent colors for semantic meaning */
   blue: string;
   green: string;
   yellow: string;
@@ -14,32 +22,64 @@ export interface Theme {
   teal: string;
   purple: string;
   orange: string;
+  /** Border and divider color */
   border: string;
+  /** Subtle border for inner dividers */
+  borderAlt: string;
+  /** Darkest thin colorblock - thicker than border, acts as visual separator */
+  separator: string;
+  /** Selection/hover background */
   selectionBg: string;
+  /** Selection/hover text */
   selectionText: string;
+  /** Success state color */
+  success: string;
+  /** Warning state color */
+  warning: string;
+  /** Error state color */
+  error: string;
 }
 
 const THEMES: Record<string, Theme> = {
+  "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: "#1e1e2e", surface: "#181825", text: "#cdd6f4", muted: "#6c7086",
+    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: "#45475a", selectionBg: "#2d5bcf", selectionText: "#ffffff",
+    border: "#1C1C1C", borderAlt: "#2a2a2a", separator: "#1C1C1C",
+    selectionBg: "#2A2A9C", selectionText: "#ffffff",
+    success: "#a6e3a1", warning: "#f9e2af", error: "#f38ba8",
   },
   dracula: {
     name: "dracula",
-    bg: "#282a36", surface: "#21222c", text: "#f8f8f2", muted: "#6272a4",
+    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: "#44475a", selectionBg: "#bd93f9", selectionText: "#282a36",
+    border: "#1C1C1C", borderAlt: "#2a2a2a", separator: "#1C1C1C",
+    selectionBg: "#2A2A9C", selectionText: "#ffffff",
+    success: "#50fa7b", warning: "#f1fa8c", error: "#ff5555",
   },
   monokai: {
     name: "monokai",
-    bg: "#272822", surface: "#1e1f1c", text: "#f8f8f2", muted: "#75715e",
+    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: "#49483e", selectionBg: "#e6db74", selectionText: "#272822",
+    border: "#1C1C1C", borderAlt: "#2a2a2a", separator: "#1C1C1C",
+    selectionBg: "#2A2A9C", selectionText: "#f8f8f2",
+    success: "#a6e22e", warning: "#e6db74", error: "#f92672",
   },
 };