github-search-cli 0.8.1 → 0.9.0

package/src/cli.ts

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 /** CLI entry point — routes between TUI browser and non-interactive modes. */
-import { parseQuery, applyFlagFilters, rankRepos, createGitHubSearch } from "./search";
-import { formatRepos, type ExportFormat } from "./export";
-import { formatLines, pipeExec, type FormatLine } from "./pipe";
+import { parseQuery, applyFlagFilters, rankRepos, createGitHubSearch, createTrendingSearch } from "./search";
+import { format as formatOutput, exportToFile, pipeExec, type Format, type ExportFormat, type FormatLine } from "./output";
 import { runWatch } from "./watch";
 import { runInitWizard } from "./init";
 import { readFileSync } from "fs";
@@ -158,13 +157,13 @@ Options:
   }
 
   // Determine output format
-  const format: ExportFormat | undefined =
+  const outputFormat: ExportFormat | undefined =
     flags.json ? "json" : flags.csv ? "csv" : flags.markdown ? "markdown" : undefined;
-  const isNonInteractive = format || flags.count || flags.format || flags.pipe || flags.watch;
+  const isNonInteractive = outputFormat || flags.count || flags.format || flags.pipe || flags.watch;
 
   // Non-interactive mode
   if (isNonInteractive) {
-    await runNonInteractive(flags, format);
+    await runNonInteractive(flags, outputFormat);
     return;
   }
 
@@ -172,65 +171,95 @@ Options:
   await launchBrowser();
 }
 
-async function runNonInteractive(flags: CLIFlags, format?: ExportFormat) {
-  const query = flags.query;
-  const provider = createGitHubSearch(undefined, flags.token ? [flags.token] : []);
-
-  // --watch mode
-  if (flags.watch) {
-    let tick = 0;
-    await runWatch(
-      { query, sort: flags.sort, limit: flags.limit, token: flags.token, intervalMs: flags.interval * 1000, trending: flags.trending },
-      (repos, delta) => {
-        tick++;
-        if (format) {
-          console.log(`[Watch #${tick}] ${repos.length} results (${delta >= 0 ? "+" : ""}${delta} since last check)`);
-          console.log(formatRepos(repos, format));
-        } else {
-          console.log(`[Watch #${tick}] ${repos.length} results — ${delta >= 0 ? "+" : ""}${delta} since last check`);
-        }
-      },
-      (err) => console.error(`[Watch error] ${err.message}`),
-    );
-    return;
-  }
-
-  // --pipe mode
-  if (flags.pipe) {
-    const parsed = applyFlagFilters(parseQuery(query), {});
-    const response = await provider.search(parsed, { limit: flags.limit, sort: flags.sort, json: false, verbose: false, token: flags.token });
-    const repos = rankRepos(response.repos, flags.sort);
-    await pipeExec(repos, flags.pipe);
-    return;
-  }
+interface SearchContext {
+  query: string;
+  parsed: ReturnType<typeof parseQuery> & { raw: string };
+  provider: ReturnType<typeof createGitHubSearch>;
+}
 
-  // --format mode
-  if (flags.format) {
-    const parsed = applyFlagFilters(parseQuery(query), {});
-    const response = await provider.search(parsed, { limit: flags.limit, sort: flags.sort, json: false, verbose: false, token: flags.token });
-    const repos = rankRepos(response.repos, flags.sort);
-    console.log(formatLines(repos, flags.format as FormatLine));
-    return;
-  }
+function buildSearchContext(flags: CLIFlags): SearchContext {
+  const parsed = applyFlagFilters(parseQuery(flags.query), {});
+  return {
+    query: flags.query,
+    parsed,
+    provider: createGitHubSearch(undefined, flags.token ? [flags.token] : []),
+  };
+}
 
-  // Standard search with format
-  const parsed = applyFlagFilters(parseQuery(query), {});
-  const response = await provider.search(parsed, {
-    limit: flags.limit, sort: flags.sort, json: false, verbose: false, token: flags.token,
-  });
-  const repos = rankRepos(response.repos, flags.sort);
+async function runNonInteractive(flags: CLIFlags, outputFormat?: ExportFormat) {
+  // Dispatch table: each handler receives shared context + flags, returns void.
+  const handlers: Record<string, (ctx: SearchContext) => Promise<void>> = {
+    trending: async (ctx) => {
+      const since = flags.since === "weekly" ? "weekly" : flags.since === "monthly" ? "monthly" : "daily";
+      const trendingSearch = createTrendingSearch();
+      const response = await trendingSearch.search(
+        { keywords: [], qualifiers: [], raw: "trending" },
+        { limit: 25, sort: "stars", json: false, verbose: false, trendingSince: since },
+      );
+      if (outputFormat) {
+        console.log(formatOutput(response.repos, outputFormat));
+      } else if (flags.count) {
+        console.log(response.totalCount);
+      } else {
+        for (const r of response.repos) {
+          console.log(r.fullName + "  ★ " + r.stars + "  ▲ +" + r.score + " " + since + "  ● " + (r.language ?? ""));
+        }
+      }
+    },
+    watch: async (ctx) => {
+      let tick = 0;
+      await runWatch(
+        { query: ctx.query, sort: flags.sort, limit: flags.limit, token: flags.token, intervalMs: flags.interval * 1000, trending: flags.trending },
+        (repos, delta) => {
+          tick++;
+          if (outputFormat) {
+            console.log(`[Watch #${tick}] ${repos.length} results (${delta >= 0 ? "+" : ""}${delta} since last check)`);
+            console.log(formatOutput(repos, outputFormat));
+          } else {
+            console.log(`[Watch #${tick}] ${repos.length} results — ${delta >= 0 ? "+" : ""}${delta} since last check`);
+          }
+        },
+        (err) => console.error(`[Watch error] ${err.message}`),
+      );
+    },
+    pipe: async (ctx) => {
+      const response = await ctx.provider.search(ctx.parsed, {
+        limit: flags.limit, sort: flags.sort, json: false, verbose: false, token: flags.token,
+      });
+      const repos = rankRepos(response.repos, flags.sort);
+      await pipeExec(repos, flags.pipe!);
+    },
+    format: async (ctx) => {
+      const response = await ctx.provider.search(ctx.parsed, {
+        limit: flags.limit, sort: flags.sort, json: false, verbose: false, token: flags.token,
+      });
+      const repos = rankRepos(response.repos, flags.sort);
+      console.log(formatOutput(repos, flags.format as Format));
+    },
+    search: async (ctx) => {
+      const response = await ctx.provider.search(ctx.parsed, {
+        limit: flags.limit, sort: flags.sort, json: false, verbose: false, token: flags.token,
+      });
+      const repos = rankRepos(response.repos, flags.sort);
+      if (flags.count) {
+        console.log(response.totalCount);
+        return;
+      }
+      if (outputFormat) {
+        console.log(formatOutput(repos, outputFormat));
+      }
+    },
+  };
 
-  // --count
-  if (flags.count) {
-    console.log(response.totalCount);
-    return;
-  }
+  // Determine which handler to run
+  const key = flags.trending && !flags.watch ? "trending"
+    : flags.watch ? "watch"
+    : flags.pipe ? "pipe"
+    : flags.format ? "format"
+    : "search";
 
-  // --json, --csv, --markdown
-  if (format) {
-    console.log(formatRepos(repos, format));
-    return;
-  }
+  const ctx = buildSearchContext(flags);
+  await handlers[key](ctx);
 }
 
 main().catch((err) => {

package/src/config.ts

@@ -9,7 +9,7 @@
 import type { Config } from "./types";
 import { homedir } from "os";
 import { join } from "path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
 
 /** Directory for persistent state (history, bookmarks, session). */
 export function stateDir(): string {
@@ -27,7 +27,7 @@ export function cacheDir(): string {
 const DEFAULTS: Config = {
   defaultSort: "best-match",
   defaultLimit: 50,
-  theme: "tokyo-night",
+  theme: "premium-dark",  // New default: premium dark with sharp edges
   cacheTtlSeconds: 300,
   defaultTab: "search",
 };

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). */