github-search-cli 0.8.2 → 0.9.0

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",
   },
 };