github-search-cli 0.8.2 → 0.9.0

package/src/history.ts

@@ -1,53 +1,30 @@
 /**
  * Persistent search history — append-only JSONL with rotation.
  */
-import { existsSync, mkdirSync, readFileSync, appendFileSync, writeFileSync, unlinkSync } from "fs";
-import { join } from "path";
 import type { HistoryEntry } from "./types";
-import { stateDir } from "./config";
+import { readJSONL, appendJSONL, writeJSON, writeRaw } from "./storage";
 
-const HISTORY_FILE = join(stateDir(), "history.jsonl");
+const HISTORY_FILE = "history.jsonl";
 const MAX_ENTRIES = 500;
 
-function ensureDir() {
-  mkdirSync(stateDir(), { recursive: true });
-}
-
 /** Append one entry to the history log. */
 export function appendHistory(entry: HistoryEntry): void {
-  ensureDir();
-  const line = JSON.stringify(entry) + "\n";
-  try {
-    appendFileSync(HISTORY_FILE, line, "utf-8");
-  } catch {
-    // non-critical
-  }
+  appendJSONL(HISTORY_FILE, entry);
 }
 
 /** Read all history entries, newest first, deduplicating consecutive identical queries. */
 export function readHistory(): HistoryEntry[] {
-  try {
-    const raw = readFileSync(HISTORY_FILE, "utf-8").trim();
-    if (!raw) return [];
-    const lines = raw.split("\n").filter(Boolean);
-    const entries: HistoryEntry[] = lines.map((l) => JSON.parse(l) as HistoryEntry);
-
-    // Sorted oldest-first in file; reverse to newest-first
-    entries.reverse();
-
-    // Deduplicate consecutive identical queries (keep newest)
-    const deduped: HistoryEntry[] = [];
-    let lastQuery: string | undefined;
-    for (const e of entries) {
-      if (e.query !== lastQuery) {
-        deduped.push(e);
-        lastQuery = e.query;
-      }
+  const entries = readJSONL<HistoryEntry>(HISTORY_FILE);
+  entries.reverse();
+  const deduped: HistoryEntry[] = [];
+  let lastQuery: string | undefined;
+  for (const e of entries) {
+    if (e.query !== lastQuery) {
+      deduped.push(e);
+      lastQuery = e.query;
     }
-    return deduped;
-  } catch {
-    return [];
   }
+  return deduped;
 }
 
 /** Delete a single history entry by index (0 = newest). */
@@ -55,20 +32,13 @@ export function deleteHistoryEntry(index: number): void {
   const entries = readHistory();
   if (index < 0 || index >= entries.length) return;
   const removed = entries[index];
-  // Rewrite file without the removed entry
   const remaining = entries.filter((e) => e.timestamp !== removed.timestamp || e.query !== removed.query);
-  ensureDir();
-  // Reverse back to oldest-first for file order
-  writeFileSync(HISTORY_FILE, remaining.reverse().map((e) => JSON.stringify(e)).join("\n") + "\n");
+  writeRaw(HISTORY_FILE, remaining.reverse().map((e) => JSON.stringify(e)).join("\n") + "\n");
 }
 
 /** Clear all history. */
 export function clearHistory(): void {
-  try {
-    writeFileSync(HISTORY_FILE, "");
-  } catch {
-    // non-critical
-  }
+  writeRaw(HISTORY_FILE, "");
 }
 
 /** Rotate history to max entries (trim oldest). */
@@ -76,16 +46,10 @@ export function rotateHistory(): void {
   const entries = readHistory();
   if (entries.length <= MAX_ENTRIES) return;
   const trimmed = entries.slice(0, MAX_ENTRIES);
-  ensureDir();
-  writeFileSync(HISTORY_FILE, trimmed.reverse().map((e) => JSON.stringify(e)).join("\n") + "\n");
+  writeRaw(HISTORY_FILE, trimmed.reverse().map((e) => JSON.stringify(e)).join("\n") + "\n");
 }
 
 /** Count entries in history file. */
 export function historyCount(): number {
-  try {
-    const raw = readFileSync(HISTORY_FILE, "utf-8").trim();
-    return raw ? raw.split("\n").length : 0;
-  } catch {
-    return 0;
-  }
+  return readJSONL<HistoryEntry>(HISTORY_FILE).length;
 }

package/src/notifications.ts

@@ -1,7 +1,5 @@
 /** Notification center — ephemeral alerts for rate limits, watch changes, etc. */
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import { stateDir } from "./config";
+import { readJSON, writeJSON } from "./storage";
 
 export interface Notification {
   id: number;
@@ -14,20 +12,15 @@ export interface Notification {
 let nextId = 1;
 let notifs: Notification[] = [];
 const MAX_NOTIFS = 50;
-const FILE = join(stateDir(), "notifications.json");
+const FILE = "notifications.json";
 
 function load(): void {
-  try {
-    notifs = JSON.parse(readFileSync(FILE, "utf-8"));
-    nextId = (Math.max(...notifs.map((n) => n.id), 0) + 1);
-  } catch {
-    notifs = [];
-  }
+  notifs = readJSON<Notification[]>(FILE, []);
+  nextId = Math.max(...notifs.map((n) => n.id), 0) + 1;
 }
 
 function save(): void {
-  mkdirSync(stateDir(), { recursive: true });
-  writeFileSync(FILE, JSON.stringify(notifs));
+  writeJSON(FILE, notifs);
 }
 
 export function addNotification(type: Notification["type"], message: string): Notification {

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