github-search-cli 9.1.0 → 9.2.1

package/src/package-browser.ts

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+/** package-browser.ts — "Packages" browse/list view for the ghfind CLI. */
+import {
+  createCliRenderer,
+  BoxRenderable,
+  TextRenderable,
+  ScrollBoxRenderable,
+  StyledText,
+  bold,
+  fg,
+  dim,
+  t,
+} from "@opentui/core";
+import type { TextChunk, CliRenderer } from "@opentui/core";
+import type { Package } from "./types";
+import { openUrl } from "./open-url";
+import { createPackageSearch } from "./package";
+const C = {
+  bg: "#1a1b26",
+  surface: "#16161e",
+  text: "#a9b1d6",
+  muted: "#565f89",
+  cyan: "#7dcfff",
+  purple: "#bb9af7",
+  green: "#9ece6a",
+  gold: "#e0af68",
+  orange: "#ff9e64",
+  red: "#f7768e",
+  blue: "#7aa2f7",
+  lightBlue: "#b4f9f8",
+  selectionBg: "#3b6ce8",
+  selectionText: "#c0caf5",
+  border: "#363b54",
+  descText: "#6c7086", // lighter muted for descriptions
+  nameText: "#c0caf5", // bright for package names
+};
+// ─── Number formatting ────────────────────────────────────────────────
+const INT_FMT = new Intl.NumberFormat("en-US");
+/** 523219736 → "523,219,736" (full downloads tally, no compaction) */
+function fmtCount(n: number): string {
+  return INT_FMT.format(Math.trunc(n));
+}
+// ─── Row formatting ───────────────────────────────────────────────────
+/** Format one package as a 2-line StyledText (name line + description line). */
+function formatPackageLine(pack: Package): StyledText {
+  const nameStr = `${pack.name}@${pack.version}`.padEnd(28).slice(0, 28);
+  const dlStr = `↓ ${fmtCount(pack.downloads)}`.padEnd(20).slice(0, 20);
+  const scoreStr = `score ${pack.score.toFixed(2)}`.padEnd(12).slice(0, 12);
+  const desc = (pack.description ?? "").length > 60
+    ? (pack.description ?? "").slice(0, 57) + "..."
+    : (pack.description ?? "");
+  const line1 = t`${bold(fg(C.nameText)(nameStr))}${fg(C.cyan)(dlStr)}${fg(C.gold)(scoreStr)}`;
+  const line2 = t`${dim(fg(C.descText)(`     ${desc}`))}`;
+  const newline: TextChunk = { text: "\n", __isChunk: true as const };
+  const chunks: TextChunk[] = [...line1.chunks, newline, ...line2.chunks];
+  return new StyledText(chunks);
+}
+// ─── Main TUI entry ───────────────────────────────────────────────────
+export async function launchPackageBrowser(): Promise<void> {
+  let renderer: CliRenderer;
+  try {
+    renderer = await createCliRenderer();
+  } catch (err) {
+    console.error(
+      "Failed to start the interactive browser.\n",
+      `Reason: ${err instanceof Error ? err.message : String(err)}\n`,
+    );
+    process.exit(1);
+    return;
+  }
+  const root = renderer.root;
+  root.flexDirection = "column";
+  // ── State ──
+  let query = "";
+  let dirty = false; // input edited since last search → Enter re-runs the search
+  let packages: Package[] = [];
+  let selectedIdx = 0;
+  let isLoading = false;
+  // ── Outer frame ──
+  const outerBox = new BoxRenderable(renderer, {
+    flexGrow: 1,
+    flexDirection: "column",
+    backgroundColor: C.bg,
+    border: true,
+    borderColor: C.border,
+    borderStyle: "rounded",
+    paddingX: 0,
+    paddingY: 0,
+  });
+  // ── Header bar ──
+  const headerBox = new BoxRenderable(renderer, {
+    height: 1,
+    backgroundColor: C.bg,
+    paddingX: 1,
+  });
+  const headerText = new TextRenderable(renderer, {
+    content: t`${bold(fg(C.purple)("⟠ tulipsearch"))}${fg(C.muted)(" — Packages")}`,
+    fg: C.purple,
+    bg: C.bg,
+    height: 1,
+  });
+  headerBox.add(headerText);
+  outerBox.add(headerBox);
+  // ── Query input line ──
+  const inputBox = new BoxRenderable(renderer, {
+    height: 1,
+    flexDirection: "row",
+    backgroundColor: C.surface,
+    paddingX: 1,
+  });
+  let inputText: TextRenderable | null = null;
+  function renderInput() {
+    if (inputText) inputBox.remove(inputText);
+    const cursor = isLoading ? " " : "▊";
+    inputText = new TextRenderable(renderer, {
+      content: t`${fg(C.cyan)("❯ ")}${query}${dim(fg(C.muted)(cursor))}`,
+      fg: C.text,
+      bg: C.surface,
+      height: 1,
+    });
+    inputBox.add(inputText);
+  }
+  // ── Status line (loading / error / result count) ──
+  const statusBox = new BoxRenderable(renderer, {
+    height: 1,
+    backgroundColor: C.bg,
+    paddingX: 1,
+  });
+  let statusText: TextRenderable | null = null;
+  function setStatus(cfg: { content: StyledText; color?: string }) {
+    if (statusText) statusBox.remove(statusText);
+    statusText = new TextRenderable(renderer, {
+      content: cfg.content,
+      fg: cfg.color ?? C.text,
+      bg: C.bg,
+      height: 1,
+    });
+    statusBox.add(statusText);
+  }
+  // ── Package list (scrollable) ──
+  const scrollBox = new ScrollBoxRenderable(renderer, {
+    flexGrow: 1,
+    backgroundColor: C.bg,
+    scrollY: true,
+    scrollX: false,
+    viewportCulling: true,
+  });
+  const rowBoxes: BoxRenderable[] = [];
+  const rowTexts: TextRenderable[] = [];
+  function clearRows() {
+    for (const rb of rowBoxes) scrollBox.remove(rb);
+    rowBoxes.length = 0;
+    rowTexts.length = 0;
+  }
+  function rebuildList() {
+    clearRows();
+    packages.forEach((p, i) => {
+      const isEven = i % 2 === 0;
+      const isSelected = i === selectedIdx;
+      const rowBg = isSelected ? C.selectionBg : (isEven ? C.bg : C.surface);
+      const rowText = new TextRenderable(renderer, {
+        content: formatPackageLine(p),
+        bg: rowBg,
+        height: 2,
+      });
+      const rowBox = new BoxRenderable(renderer, {
+        flexDirection: "row",
+        backgroundColor: rowBg,
+      });
+      rowBox.add(rowText);
+      rowBoxes.push(rowBox);
+      rowTexts.push(rowText);
+      scrollBox.add(rowBox);
+    });
+  }
+  // ── Footer bar ──
+  const footerBox = new BoxRenderable(renderer, {
+    height: 1,
+    backgroundColor: C.bg,
+    paddingX: 1,
+  });
+  const footerText = new TextRenderable(renderer, {
+    content: " type query ↵ search   ↑↓ navigate   ↵ open   q/esc quit",
+    fg: C.muted,
+    bg: C.bg,
+    height: 1,
+  });
+  footerBox.add(footerText);
+  outerBox.add(footerBox);
+  root.add(outerBox);
+  outerBox.add(inputBox);
+  outerBox.add(statusBox);
+  const divider = new TextRenderable(renderer, {
+    content: "─".repeat(80),
+    fg: C.border,
+    bg: C.bg,
+    height: 1,
+  });
+  outerBox.add(divider);
+  outerBox.add(scrollBox);
+  // ── Fetch ──
+  async function runSearch() {
+    const q = query.trim();
+    if (!q) return;
+    isLoading = true;
+    dirty = false;
+    clearRows();
+    setStatus({ content: t`${dim(fg(C.muted)(`  Loading packages for "${q}"...`))}` });
+    renderer.requestRender();
+    try {
+      const searcher = createPackageSearch();
+      const res = await searcher.searchPackage(q, 25);
+      packages = res.packages;
+      selectedIdx = 0;
+      rebuildList();
+      setStatus({
+        content: t`${fg(C.muted)(`  ${packages.length} of ${fmtCount(res.totalCount)} results for `)}${fg(C.cyan)(`"${q}"`)}`,
+      });
+    } catch (err) {
+      packages = [];
+      clearRows();
+      const msg = err instanceof Error ? err.message : String(err);
+      setStatus({
+        content: t`${fg(C.red)(`  Error: ${msg.slice(0, 70)} — press ↵ to retry`)}`,
+      });
+    }
+    isLoading = false;
+    renderInput();
+    renderer.requestRender();
+  }
+  // ── Helpers ──
+  function openSelectedPackage() {
+    if (selectedIdx < 0 || selectedIdx >= packages.length) return;
+    const p = packages[selectedIdx];
+    openUrl(p.url);
+  }
+  function moveSelection(delta: number) {
+    const oldIdx = selectedIdx;
+    const newIdx = Math.max(0, Math.min(packages.length - 1, oldIdx + delta));
+    if (newIdx === oldIdx) return;
+    selectedIdx = newIdx;
+    const setBg = (idx: number, selected: boolean) => {
+      if (idx < 0 || idx >= rowBoxes.length) return;
+      const bg = selected ? C.selectionBg : (idx % 2 === 0 ? C.bg : C.surface);
+      rowBoxes[idx].backgroundColor = bg;
+      if (rowTexts[idx]) rowTexts[idx].bg = bg;
+    };
+    setBg(oldIdx, false);
+    setBg(newIdx, true);
+    renderer.requestRender();
+  }
+  // ── Global key events ──
+  renderer.keyInput.on("keypress", (key: import("@opentui/core").KeyEvent) => {
+    const name = key.name || "";
+    if (name === "q" || name === "escape") {
+      process.exit(0);
+      return;
+    }
+    if (name === "backspace") {
+      query = query.slice(0, -1);
+      dirty = true;
+      renderInput();
+      renderer.requestRender();
+      return;
+    }
+    if (name === "space") {
+      query += " ";
+      dirty = true;
+      renderInput();
+      renderer.requestRender();
+      return;
+    }
+    // Printable single-char inputs edit the query.
+    if (name.length === 1) {
+      query += name;
+      dirty = true;
+      renderInput();
+      renderer.requestRender();
+      return;
+    }
+    if (name === "up" || name === "k") {
+      moveSelection(-1);
+      return;
+    }
+    if (name === "down" || name === "j") {
+      moveSelection(1);
+      return;
+    }
+    if (name === "enter" || name === "return") {
+      if (dirty || packages.length === 0) {
+        runSearch();
+      } else {
+        openSelectedPackage();
+      }
+      return;
+    }
+  });
+  // ── Start ──
+  renderer.start();
+  renderInput();
+  setStatus({
+    content: t`${fg(C.muted)("  Type a package query above and press ↵ to search")}`,
+  });
+  renderer.requestRender();
+}

package/src/package.ts

@@ -0,0 +1,137 @@
+/**
+ * package.ts — package-registry search provider (prototype for ticket 002-008).
+ *
+ * npm-only for the MVP (ticket 002-005). Query is passed through verbatim to npm's
+ * native `/-/v1/search` (ticket 002-006) and the response normalized to the parallel
+ * `Package` shape (ticket 002-007). Rough on purpose — this is the artifact to react to.
+ */
+import type { Package } from "./types";
+
+export interface PackageSearchResult {
+  totalCount: number;
+  packages: Package[];
+}
+
+/** The npm `/-/v1/search` object shape we actually consume (research 002-001). */
+interface NpmSearchObject {
+  package: {
+    name?: string;
+    scope?: string;
+    version?: string;
+    description?: string | null;
+    keywords?: string[];
+    date?: string;
+    links?: { npm?: string; homepage?: string; repository?: string };
+    publisher?: { username?: string };
+    author?: { name?: string };
+  };
+  score?: { final?: number; detail?: { quality?: number; popularity?: number; maintenance?: number } };
+  searchScore?: number;
+  downloads?: { npm?: number; total?: number; monthly?: number };
+}
+
+export function normalizeNpmObject(obj: NpmSearchObject): Package {
+  const p = obj.package;
+  const name = p.name ?? "";
+  return {
+    name,
+    version: p.version ?? "",
+    description: p.description ?? null,
+    url: p.links?.npm ?? `https://www.npmjs.com/package/${name}`,
+    downloads: obj.downloads?.monthly ?? 0,
+    score: obj.score?.final ?? obj.searchScore ?? 0,
+    publisher: p.publisher?.username ?? p.author?.name ?? null,
+    keywords: p.keywords ?? [],
+    registry: "npm",
+  };
+}
+
+export function createPackageSearch() {
+  return {
+    async searchPackage(rawQuery: string, limit: number): Promise<PackageSearchResult> {
+      const size = Math.min(Math.max(Math.trunc(limit) || 50, 1), 250); // npm caps size at 250
+      const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(rawQuery)}&size=${size}`;
+      const res = await fetch(url, {
+        headers: { "User-Agent": "ghfind", Accept: "application/json" },
+      });
+      if (!res.ok) {
+        throw new Error(`npm search failed: HTTP ${res.status}`);
+      }
+      const data = (await res.json()) as { objects?: NpmSearchObject[]; total?: number };
+      const packages = (data.objects ?? []).map(normalizeNpmObject);
+      return { totalCount: data.total ?? packages.length, packages };
+    },
+  };
+}
+
+/** Sort strategies for package results (npm registry order IS best-match). */
+export type PackageSortMode = "best-match" | "score" | "downloads" | "name";
+
+/** Sort modes in cycle order for the TUI Sort menu. */
+export const PACKAGE_SORT_MODES: { key: PackageSortMode; label: string }[] = [
+  { key: "best-match", label: "best-match" },
+  { key: "downloads", label: "downloads" },
+  { key: "score", label: "score" },
+  { key: "name", label: "name" },
+];
+
+/**
+ * Sort fetched packages. "best-match" is a no-op: it preserves the registry's
+ * relevance order, which is the canonical npm ranking.
+ */
+export function sortPackages(pkgs: Package[], sort: PackageSortMode): Package[] {
+  if (sort === "best-match" || pkgs.length < 2) return pkgs;
+  const arr = [...pkgs];
+  if (sort === "score") {
+    arr.sort((a, b) => b.score - a.score);
+  } else if (sort === "downloads") {
+    arr.sort((a, b) => b.downloads - a.downloads);
+  } else {
+    arr.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  return arr;
+}
+
+// ── Package output formatters (parallel to output.ts for repo) ─────────
+// Entity model (ticket 002-007): json/text/count/limit are shared generics
+// (json uses JSON.stringify on Package[]); csv/markdown/urls/names get package
+// variants here. git-only formats (ssh-urls, clone-commands, ids) stay repo-only.
+
+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 formatPackagesJson(pkgs: Package[]): string {
+  return JSON.stringify(pkgs, null, 2);
+}
+
+export function formatPackagesCsv(pkgs: Package[]): string {
+  const header = "rank,name,version,downloads,score,url";
+  const rows = pkgs.map(
+    (p, i) =>
+      `${i + 1},${csvEscape(p.name)},${p.version},${p.downloads},${p.score.toFixed(2)},${csvEscape(p.url)}`,
+  );
+  return [header, ...rows].join("\n");
+}
+
+export function formatPackagesMarkdown(pkgs: Package[]): string {
+  const header = "| # | Package | Version | Downloads | Score |";
+  const sep = "|---|---------|---------|-----------|-------|";
+  const rows = pkgs.map(
+    (p, i) =>
+      `| ${i + 1} | [${p.name}@${p.version}](${p.url}) | ${p.version} | ${p.downloads.toLocaleString()} | ${p.score.toFixed(2)} |`,
+  );
+  return [header, sep, ...rows].join("\n");
+}
+
+export function formatPackagesUrls(pkgs: Package[]): string {
+  return pkgs.map((p) => p.url).join("\n");
+}
+
+export function formatPackagesNames(pkgs: Package[]): string {
+  return pkgs.map((p) => p.name).join("\n");
+}

package/src/search.ts

@@ -612,6 +612,7 @@ export class SearchModule implements SearchProvider {
       options.sort,
       String(options.limit),
       String(options.page ?? 1),
+      options.trendingSince ?? "none",
     );
     const cached = SearchModule.cache.get(cacheKey);
     if (cached) {

package/src/themes.ts

@@ -38,48 +38,72 @@ export interface Theme {
   warning: string;
   /** Error state color */
   error: string;
+  /** Modal/overlay panel background (darker than surface) */
+  surfaceDim: string;
+  /** Primary accent for titles and highlights */
+  accent: string;
+  /** Dimmed accent for secondary accents */
+  accentDim: string;
+  /** Border for floating/modal panels */
+  borderAccent: 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: "#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",
+    // Genuine Tokyo Night palette — cool blue-violet mood
+    bg: "#1a1b26",
+    surface: "#24283b",
+    surfaceAlt: "#292e42",
+    text: "#c0caf5",
+    muted: "#565f89",
+    blue: "#7aa2f7",
+    green: "#9ece6a",
+    yellow: "#e0af68",
+    red: "#f7768e",
+    teal: "#73daca",
+    purple: "#bb9af7",
+    orange: "#ff9e64",
+    border: "#24283b",
+    borderAlt: "#1f2335",
+    separator: "#1f2335",
+    selectionBg: "#2d3f76",
+    selectionText: "#c0caf5",
+    success: "#9ece6a",
+    warning: "#e0af68",
+    error: "#f7768e",
+    surfaceDim: "#16161e",
+    accent: "#7aa2f7",
+    accentDim: "#5d7abf",
+    borderAccent: "#1f2335",
   },
-  dracula: {
-    name: "dracula",
-    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: "#1C1C1C", borderAlt: "#2a2a2a", separator: "#1C1C1C",
-    selectionBg: "#2A2A9C", selectionText: "#ffffff",
-    success: "#50fa7b", warning: "#f1fa8c", error: "#ff5555",
-  },
-  monokai: {
-    name: "monokai",
-    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: "#1C1C1C", borderAlt: "#2a2a2a", separator: "#1C1C1C",
-    selectionBg: "#2A2A9C", selectionText: "#f8f8f2",
-    success: "#a6e22e", warning: "#e6db74", error: "#f92672",
+  "premium-dark": {
+    name: "premium-dark",
+    // Warm counter-mood to Tokyo Night — amber/rust accent
+    bg: "#1e1e2e",
+    surface: "#262637",
+    surfaceAlt: "#2e2e42",
+    text: "#cdd6f4",
+    muted: "#6c7086",
+    blue: "#89b4fa",
+    green: "#a6e3a1",
+    yellow: "#f9e2af",
+    red: "#f38ba8",
+    teal: "#94e2d5",
+    purple: "#cba6f7",
+    orange: "#fab387",
+    border: "#313244",
+    borderAlt: "#2a2a3d",
+    separator: "#2a2a3d",
+    selectionBg: "#45475a",
+    selectionText: "#cdd6f4",
+    success: "#a6e3a1",
+    warning: "#f9e2af",
+    error: "#f38ba8",
+    surfaceDim: "#181825",
+    accent: "#f9e2af",
+    accentDim: "#c9a87a",
+    borderAccent: "#313244",
   },
 };
 

package/src/trending.ts

@@ -253,6 +253,14 @@ export async function launchTrending(): Promise<void> {
     paddingX: 1,
   });
   const tabTexts: TextRenderable[] = [];
+  const underlineBox = new BoxRenderable(renderer, {
+    height: 1,
+    backgroundColor: C.bg,
+    paddingX: 1,
+  });
+  function tabWidth(name: string): number {
+    return name.length + 2; // " name " padding
+  }
   function renderTabBar() {
     for (const t of tabTexts) tabBox.remove(t);
     tabTexts.length = 0;
@@ -261,8 +269,8 @@ export async function launchTrending(): Promise<void> {
       const label = ` ${name} `;
       const tt = new TextRenderable(renderer, {
         content: isActive ? t`${bold(fg(C.bg)(label))}` : t`${fg(C.muted)(label)}`,
-        color: isActive ? C.bg : C.muted,
-        backgroundColor: isActive ? C.cyan : C.bg,
+        fg: isActive ? C.bg : C.muted,
+        bg: isActive ? C.cyan : C.bg,
         height: 1,
       });
       tabTexts.push(tt);
@@ -270,17 +278,35 @@ export async function launchTrending(): Promise<void> {
       if (i < TAB_NAMES.length - 1) {
         const sp = new TextRenderable(renderer, {
           content: "  ",
-          color: C.muted,
-          backgroundColor: C.bg,
+          fg: C.muted,
+          bg: C.bg,
           height: 1,
         });
         tabTexts.push(sp);
         tabBox.add(sp);
       }
     });
+    // ── cyan underline bar under active tab ──
+    let offset = 1; // paddingX
+    for (let i = 0; i < selectedTab; i++) {
+      offset += tabWidth(TAB_NAMES[i]) + 2; // tab + separator
+    }
+    const w = tabWidth(TAB_NAMES[selectedTab]);
+    const dots = "┉".repeat(w);
+    underlineBox.remove(underlineText);
+    underlineText.content = t`${fg(C.cyan)(dots)}`;
+    underlineText.left = offset;
   }
+  const underlineText = new TextRenderable(renderer, {
+    content: "",
+    fg: C.cyan,
+    bg: C.bg,
+    height: 1,
+  });
+  underlineBox.add(underlineText);
   renderTabBar();
   outerBox.add(tabBox);
+  outerBox.add(underlineBox);
   const divider = new TextRenderable(renderer, {
     content: "─".repeat(80),
     color: C.border,
@@ -357,7 +383,7 @@ export async function launchTrending(): Promise<void> {
     paddingX: 1,
   });
   const footerText = new TextRenderable(renderer, {
-    content: " ↑↓ navigate  ↵ open  / search  1-5 tab  q quit  r refresh",
+    content: " ↑↓ navigate  ↵ open  / search  1-3 tab  q quit  r refresh",
     color: C.muted,
     height: 1,
   });