ghbounty 1.0.0

package/dist/store.js

@@ -0,0 +1,107 @@
+/**
+ * store.ts — Persistent storage for stats and watch state.
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const DATA_DIR = join(homedir(), ".ghbounty");
+const STATS_FILE = join(DATA_DIR, "stats.json");
+const SEEN_FILE = join(DATA_DIR, "seen.json");
+function ensureDir() {
+    if (!existsSync(DATA_DIR)) {
+        mkdirSync(DATA_DIR, { recursive: true });
+    }
+}
+function readJSON(filepath, fallback) {
+    try {
+        const data = readFileSync(filepath, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeJSON(filepath, data) {
+    ensureDir();
+    writeFileSync(filepath, JSON.stringify(data, null, 2), "utf-8");
+}
+const DEFAULT_STATS = {
+    totalScans: 0,
+    totalBountiesFound: 0,
+    totalValueTracked: 0,
+    languageCounts: {},
+    repoCounts: {},
+    lastScanAt: null,
+};
+/**
+ * Load stats from disk.
+ */
+export function loadStats() {
+    return readJSON(STATS_FILE, { ...DEFAULT_STATS });
+}
+/**
+ * Save stats to disk.
+ */
+export function saveStats(stats) {
+    writeJSON(STATS_FILE, stats);
+}
+/**
+ * Record a scan result in stats.
+ */
+export function recordScan(bountyCount, totalValue, languages, repos) {
+    const stats = loadStats();
+    stats.totalScans++;
+    stats.totalBountiesFound += bountyCount;
+    stats.totalValueTracked += totalValue;
+    stats.lastScanAt = new Date().toISOString();
+    for (const lang of languages) {
+        if (lang) {
+            stats.languageCounts[lang] = (stats.languageCounts[lang] || 0) + 1;
+        }
+    }
+    for (const repo of repos) {
+        stats.repoCounts[repo] = (stats.repoCounts[repo] || 0) + 1;
+    }
+    saveStats(stats);
+}
+/**
+ * Get formatted stats for display.
+ */
+export function getFormattedStats() {
+    const stats = loadStats();
+    const topLanguages = Object.entries(stats.languageCounts)
+        .map(([lang, count]) => ({ lang, count }))
+        .sort((a, b) => b.count - a.count);
+    const topRepos = Object.entries(stats.repoCounts)
+        .map(([repo, count]) => ({ repo, count }))
+        .sort((a, b) => b.count - a.count);
+    return {
+        totalScans: stats.totalScans,
+        totalBountiesFound: stats.totalBountiesFound,
+        totalValueTracked: stats.totalValueTracked,
+        topLanguages,
+        topRepos,
+        lastScanAt: stats.lastScanAt,
+    };
+}
+/**
+ * Load the set of previously seen bounty URLs.
+ */
+export function loadSeenBounties() {
+    const data = readJSON(SEEN_FILE, []);
+    return new Set(data);
+}
+/**
+ * Save the set of seen bounty URLs.
+ */
+export function saveSeenBounties(seen) {
+    writeJSON(SEEN_FILE, Array.from(seen));
+}
+/**
+ * Reset all stats.
+ */
+export function resetStats() {
+    saveStats({ ...DEFAULT_STATS });
+    saveSeenBounties(new Set());
+}
+//# sourceMappingURL=store.js.map

package/dist/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "ghbounty",
+  "version": "1.0.0",
+  "description": "GitHub bounty aggregator CLI — find and track bounties across GitHub",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "ghbounty": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "github",
+    "bounty",
+    "bug-bounty",
+    "cli",
+    "open-source",
+    "rewards"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/display.ts

@@ -0,0 +1,284 @@
+/**
+ * display.ts — Table output formatting for bounty data.
+ */
+
+import type { BountyIssue } from "./scanner.js";
+
+interface Column {
+  header: string;
+  key: string;
+  width: number;
+  align?: "left" | "right" | "center";
+  formatter?: (value: any, row: BountyIssue) => string;
+}
+
+const COLUMNS: Column[] = [
+  {
+    header: "Amount",
+    key: "amountFormatted",
+    width: 10,
+    align: "right",
+    formatter: (v) => colorAmount(v),
+  },
+  {
+    header: "Repository",
+    key: "repo",
+    width: 30,
+    formatter: (v) => truncate(v, 30),
+  },
+  {
+    header: "Title",
+    key: "title",
+    width: 45,
+    formatter: (v) => truncate(v, 45),
+  },
+  {
+    header: "Lang",
+    key: "language",
+    width: 12,
+    formatter: (v) => v || "—",
+  },
+  {
+    header: "Comments",
+    key: "comments",
+    width: 8,
+    align: "right",
+  },
+  {
+    header: "Updated",
+    key: "updatedAt",
+    width: 12,
+    formatter: (v) => formatRelativeDate(v),
+  },
+];
+
+// ANSI color codes
+const COLORS = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+  bgGreen: "\x1b[42m",
+  red: "\x1b[31m",
+  magenta: "\x1b[35m",
+  underline: "\x1b[4m",
+};
+
+function c(color: keyof typeof COLORS, text: string): string {
+  return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+function colorAmount(amount: string): string {
+  if (amount === "TBD") return c("dim", amount);
+  const num = parseInt(amount.replace(/[$,]/g, ""));
+  if (num >= 1000) return c("green", c("bold", amount));
+  if (num >= 500) return c("green", amount);
+  if (num >= 100) return c("yellow", amount);
+  return amount;
+}
+
+function truncate(str: string, maxLen: number): string {
+  if (!str) return "";
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+
+function formatRelativeDate(dateStr: string): string {
+  const date = new Date(dateStr);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  if (diffDays < 30) return `${Math.floor(diffDays / 7)}w ago`;
+  if (diffDays < 365) return `${Math.floor(diffDays / 30)}mo ago`;
+  return `${Math.floor(diffDays / 365)}y ago`;
+}
+
+function pad(str: string, width: number, align: string = "left"): string {
+  // Strip ANSI codes for length calculation
+  const stripped = str.replace(/\x1b\[[0-9;]*m/g, "");
+  const diff = width - stripped.length;
+  if (diff <= 0) return str;
+
+  if (align === "right") return " ".repeat(diff) + str;
+  if (align === "center") {
+    const left = Math.floor(diff / 2);
+    return " ".repeat(left) + str + " ".repeat(diff - left);
+  }
+  return str + " ".repeat(diff);
+}
+
+/**
+ * Render a table of bounties.
+ */
+export function renderTable(bounties: BountyIssue[]): string {
+  const lines: string[] = [];
+  const sep = "  ";
+
+  // Header
+  const headerLine = COLUMNS.map((col) =>
+    c("bold", pad(col.header, col.width, col.align))
+  ).join(sep);
+  lines.push(headerLine);
+
+  // Separator
+  const separatorLine = COLUMNS.map((col) => "\u2500".repeat(col.width)).join(sep);
+  lines.push(c("dim", separatorLine));
+
+  // Rows
+  for (const bounty of bounties) {
+    const cells = COLUMNS.map((col) => {
+      let value = (bounty as any)[col.key];
+      if (col.formatter) {
+        value = col.formatter(value, bounty);
+      } else {
+        value = String(value ?? "");
+      }
+      return pad(value, col.width, col.align);
+    });
+    lines.push(cells.join(sep));
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Render a summary header.
+ */
+export function renderSummary(
+  bounties: BountyIssue[],
+  elapsed: number
+): string {
+  const totalBounties = bounties.length;
+  const withAmount = bounties.filter((b) => b.amount !== null);
+  const totalValue = withAmount.reduce((sum, b) => sum + (b.amount || 0), 0);
+  const avgValue =
+    withAmount.length > 0 ? Math.round(totalValue / withAmount.length) : 0;
+  const topAmount = withAmount.length > 0 ? withAmount[0].amount! : 0;
+
+  const lines = [
+    "",
+    c("bold", c("cyan", "  ghbounty") + " — GitHub Bounty Scanner"),
+    c("dim", `  Scanned in ${(elapsed / 1000).toFixed(1)}s`),
+    "",
+    `  ${c("bold", String(totalBounties))} bounties found  |  ` +
+      `Total: ${c("green", c("bold", "$" + totalValue.toLocaleString()))}  |  ` +
+      `Avg: ${c("yellow", "$" + avgValue.toLocaleString())}  |  ` +
+      `Top: ${c("green", c("bold", "$" + topAmount.toLocaleString()))}`,
+    "",
+  ];
+
+  return lines.join("\n");
+}
+
+/**
+ * Render a detailed view of a single bounty.
+ */
+export function renderBountyDetail(bounty: BountyIssue): string {
+  const lines = [
+    "",
+    c("bold", `  ${bounty.title}`),
+    `  ${c("dim", bounty.repo)} #${bounty.id}`,
+    "",
+    `  Amount:   ${colorAmount(bounty.amountFormatted)}`,
+    `  Author:   ${bounty.author}`,
+    `  Language: ${bounty.language || "Unknown"}`,
+    `  Labels:   ${bounty.labels.join(", ") || "none"}`,
+    `  Comments: ${bounty.comments}`,
+    `  Updated:  ${formatRelativeDate(bounty.updatedAt)}`,
+    `  URL:      ${c("underline", c("cyan", bounty.url))}`,
+    "",
+  ];
+  return lines.join("\n");
+}
+
+/**
+ * Render stats dashboard.
+ */
+export function renderStats(stats: {
+  totalScans: number;
+  totalBountiesFound: number;
+  totalValueTracked: number;
+  topLanguages: { lang: string; count: number }[];
+  topRepos: { repo: string; count: number }[];
+  lastScanAt: string | null;
+}): string {
+  const lines = [
+    "",
+    c("bold", c("cyan", "  ghbounty") + " — Your Bounty Hunting Stats"),
+    "",
+    `  Total scans:       ${c("bold", String(stats.totalScans))}`,
+    `  Bounties found:    ${c("bold", String(stats.totalBountiesFound))}`,
+    `  Value tracked:     ${c("green", c("bold", "$" + stats.totalValueTracked.toLocaleString()))}`,
+    `  Last scan:         ${stats.lastScanAt ? formatRelativeDate(stats.lastScanAt) : "never"}`,
+    "",
+  ];
+
+  if (stats.topLanguages.length > 0) {
+    lines.push(c("bold", "  Top Languages:"));
+    for (const { lang, count } of stats.topLanguages.slice(0, 5)) {
+      const bar = "\u2588".repeat(Math.min(count, 20));
+      lines.push(`    ${pad(lang, 15)} ${c("cyan", bar)} ${count}`);
+    }
+    lines.push("");
+  }
+
+  if (stats.topRepos.length > 0) {
+    lines.push(c("bold", "  Top Repositories:"));
+    for (const { repo, count } of stats.topRepos.slice(0, 5)) {
+      lines.push(`    ${pad(truncate(repo, 35), 37)} ${c("yellow", String(count))} bounties`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Render a spinner frame for loading states.
+ */
+const SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+
+export function getSpinnerFrame(tick: number): string {
+  return SPINNER_FRAMES[tick % SPINNER_FRAMES.length];
+}
+
+/**
+ * Render a "no results" message.
+ */
+export function renderNoResults(options?: { language?: string; minAmount?: number }): string {
+  const lines = [
+    "",
+    c("yellow", "  No bounties found matching your criteria."),
+    "",
+  ];
+
+  if (options?.language || options?.minAmount) {
+    lines.push(c("dim", "  Active filters:"));
+    if (options.language) {
+      lines.push(c("dim", `    Language: ${options.language}`));
+    }
+    if (options.minAmount) {
+      lines.push(c("dim", `    Min amount: $${options.minAmount}`));
+    }
+    lines.push("");
+    lines.push(c("dim", "  Try broadening your search criteria."));
+    lines.push("");
+  }
+
+  lines.push(c("dim", "  Tips:"));
+  lines.push(c("dim", "    - Set GITHUB_TOKEN for higher API rate limits"));
+  lines.push(c("dim", "    - Try: ghbounty scan --deep for broader search"));
+  lines.push("");
+
+  return lines.join("\n");
+}

package/src/index.ts

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+
+/**
+ * ghbounty — GitHub Bounty Aggregator CLI
+ *
+ * Find and track bounties across GitHub repositories.
+ */
+
+import { Command } from "commander";
+import { scanBounties, deepScan } from "./scanner.js";
+import type { ScanOptions, BountyIssue } from "./scanner.js";
+import { notifyNewBounty, notifyBatchBounties } from "./notifier.js";
+import {
+  renderTable,
+  renderSummary,
+  renderNoResults,
+  renderStats,
+  renderBountyDetail,
+  getSpinnerFrame,
+} from "./display.js";
+import {
+  recordScan,
+  getFormattedStats,
+  loadSeenBounties,
+  saveSeenBounties,
+  resetStats,
+} from "./store.js";
+
+const program = new Command();
+
+program
+  .name("ghbounty")
+  .description("GitHub bounty aggregator — find and track bounties across GitHub")
+  .version("1.0.0");
+
+// ─── scan command ───────────────────────────────────────────────────────────
+
+program
+  .command("scan")
+  .description("Scan GitHub for open bounty issues")
+  .option("--min <amount>", "Minimum bounty amount in USD", parseInt)
+  .option("--max <amount>", "Maximum bounty amount in USD", parseInt)
+  .option("--lang <language>", "Filter by programming language")
+  .option("--sort <field>", "Sort by: created, updated, comments", "updated")
+  .option("--limit <n>", "Max results to show", parseInt)
+  .option("--deep", "Deep scan with multiple search strategies")
+  .option("--json", "Output as JSON")
+  .option("--detail", "Show detailed view of each bounty")
+  .action(async (opts) => {
+    const startTime = Date.now();
+
+    // Show scanning indicator
+    process.stdout.write("\n  Scanning GitHub for bounties");
+    const spinnerInterval = setInterval(() => {
+      const frame = getSpinnerFrame(Math.floor(Date.now() / 100));
+      process.stdout.write(`\r  ${frame} Scanning GitHub for bounties...`);
+    }, 100);
+
+    try {
+      const scanOpts: ScanOptions = {
+        minAmount: opts.min,
+        maxAmount: opts.max,
+        language: opts.lang,
+        sort: opts.sort,
+        limit: opts.limit || 30,
+      };
+
+      let bounties: BountyIssue[];
+
+      if (opts.deep) {
+        bounties = await deepScan(scanOpts);
+      } else {
+        bounties = await scanBounties(scanOpts);
+      }
+
+      clearInterval(spinnerInterval);
+      process.stdout.write("\r" + " ".repeat(60) + "\r"); // Clear spinner line
+
+      const elapsed = Date.now() - startTime;
+
+      if (bounties.length === 0) {
+        console.log(renderNoResults({ language: opts.lang, minAmount: opts.min }));
+        return;
+      }
+
+      // Record stats
+      const totalValue = bounties
+        .filter((b) => b.amount !== null)
+        .reduce((sum, b) => sum + (b.amount || 0), 0);
+      recordScan(
+        bounties.length,
+        totalValue,
+        bounties.map((b) => b.language),
+        bounties.map((b) => b.repo)
+      );
+
+      if (opts.json) {
+        console.log(JSON.stringify(bounties, null, 2));
+        return;
+      }
+
+      console.log(renderSummary(bounties, elapsed));
+
+      if (opts.detail) {
+        for (const bounty of bounties) {
+          console.log(renderBountyDetail(bounty));
+        }
+      } else {
+        console.log(renderTable(bounties));
+      }
+
+      console.log(
+        `\n  \x1b[2mTip: Use --detail for full info, or --json for machine-readable output\x1b[0m\n`
+      );
+    } catch (err: any) {
+      clearInterval(spinnerInterval);
+      process.stdout.write("\r" + " ".repeat(60) + "\r");
+      console.error(`\n  \x1b[31mError:\x1b[0m ${err.message}\n`);
+      process.exit(1);
+    }
+  });
+
+// ─── watch command ──────────────────────────────────────────────────────────
+
+program
+  .command("watch")
+  .description("Continuously monitor for new bounties with desktop notifications")
+  .option("--min <amount>", "Minimum bounty amount in USD", parseInt)
+  .option("--lang <language>", "Filter by programming language")
+  .option(
+    "--interval <seconds>",
+    "Check interval in seconds (default: 300)",
+    parseInt
+  )
+  .option("--quiet", "Only notify, don't print to console")
+  .action(async (opts) => {
+    const intervalSec = opts.interval || 300;
+    const seen = loadSeenBounties();
+
+    console.log(`\n  \x1b[1m\x1b[36mghbounty\x1b[0m — Watch Mode`);
+    console.log(`  Checking every ${intervalSec}s for new bounties...`);
+    if (opts.lang) console.log(`  Language filter: ${opts.lang}`);
+    if (opts.min) console.log(`  Min amount: $${opts.min}`);
+    console.log(`  Press Ctrl+C to stop.\n`);
+
+    const check = async () => {
+      const timestamp = new Date().toLocaleTimeString();
+
+      try {
+        const bounties = await scanBounties({
+          minAmount: opts.min,
+          language: opts.lang,
+          limit: 50,
+        });
+
+        const newBounties = bounties.filter((b) => !seen.has(b.url));
+
+        if (newBounties.length > 0) {
+          // Mark as seen
+          for (const b of newBounties) {
+            seen.add(b.url);
+          }
+          saveSeenBounties(seen);
+
+          // Record stats
+          const totalValue = newBounties
+            .filter((b) => b.amount !== null)
+            .reduce((sum, b) => sum + (b.amount || 0), 0);
+          recordScan(
+            newBounties.length,
+            totalValue,
+            newBounties.map((b) => b.language),
+            newBounties.map((b) => b.repo)
+          );
+
+          // Notify
+          await notifyBatchBounties(newBounties);
+
+          if (!opts.quiet) {
+            console.log(
+              `  \x1b[32m[${timestamp}]\x1b[0m ${newBounties.length} new bounties found!`
+            );
+            console.log(renderTable(newBounties));
+            console.log();
+          }
+        } else {
+          if (!opts.quiet) {
+            process.stdout.write(
+              `\r  \x1b[2m[${timestamp}] No new bounties. Next check in ${intervalSec}s...\x1b[0m`
+            );
+          }
+        }
+      } catch (err: any) {
+        console.error(`\n  \x1b[31m[${timestamp}] Error: ${err.message}\x1b[0m`);
+      }
+    };
+
+    // Initial check
+    await check();
+
+    // Periodic checks
+    setInterval(check, intervalSec * 1000);
+  });
+
+// ─── stats command ──────────────────────────────────────────────────────────
+
+program
+  .command("stats")
+  .description("Show your bounty hunting statistics")
+  .option("--reset", "Reset all stats")
+  .option("--json", "Output as JSON")
+  .action((opts) => {
+    if (opts.reset) {
+      resetStats();
+      console.log("\n  \x1b[32mStats reset successfully.\x1b[0m\n");
+      return;
+    }
+
+    const stats = getFormattedStats();
+
+    if (opts.json) {
+      console.log(JSON.stringify(stats, null, 2));
+      return;
+    }
+
+    console.log(renderStats(stats));
+  });
+
+// ─── open command (bonus utility) ───────────────────────────────────────────
+
+program
+  .command("open <url>")
+  .description("Open a bounty URL in your browser")
+  .action((url) => {
+    import("node:child_process").then(({ execSync }) => {
+      try {
+        if (process.platform === "darwin") {
+          execSync(`open "${url}"`);
+        } else if (process.platform === "linux") {
+          execSync(`xdg-open "${url}"`);
+        } else {
+          execSync(`start "${url}"`);
+        }
+        console.log(`\n  Opened: ${url}\n`);
+      } catch {
+        console.log(`\n  Could not open browser. URL: ${url}\n`);
+      }
+    });
+  });
+
+program.parse();