gh-profile-peek 1.0.0

package/bin/cli.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { program } from 'commander';
+import { analyzeProfile } from '../src/index.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const { version } = JSON.parse(
+  readFileSync(join(__dirname, '../package.json'), 'utf8')
+);
+
+program
+  .name('gh-peek')
+  .description('Analyze any GitHub profile from your terminal')
+  .version(version)
+  .argument('<username>', 'GitHub username to analyze')
+  .option('-t, --token <token>', 'GitHub personal access token (or set GITHUB_TOKEN)')
+  .option('--top <n>', 'Number of top repos to display', '5')
+  .addHelpText(
+    'after',
+    `
+Examples:
+  $ gh-peek torvalds
+  $ gh-peek sindresorhus --top 10
+  $ GITHUB_TOKEN=ghp_xxx gh-peek octocat
+  $ gh-peek octocat --token ghp_xxx`
+  )
+  .action(async (username, options) => {
+    await analyzeProfile(username, options);
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "gh-profile-peek",
+  "version": "1.0.0",
+  "description": "Analyze any GitHub profile from your terminal — languages, top repos, activity",
+  "type": "module",
+  "bin": {
+    "gh-peek": "./bin/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "github",
+    "cli",
+    "profile",
+    "analyzer",
+    "developer-tools",
+    "terminal"
+  ],
+  "license": "MIT",
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.1.0"
+  }
+}

package/src/analyze.js

@@ -0,0 +1,56 @@
+/**
+ * Merges per-repo language byte counts into a ranked percentage list.
+ * @param {object[]} repoLanguageMaps  Array of { Language: bytes } objects
+ * @returns {{ lang: string, pct: number }[]}  Top 8, sorted descending
+ */
+export function analyzeLanguages(repoLanguageMaps) {
+  const totals = {};
+
+  for (const map of repoLanguageMaps) {
+    for (const [lang, bytes] of Object.entries(map)) {
+      totals[lang] = (totals[lang] || 0) + bytes;
+    }
+  }
+
+  const total = Object.values(totals).reduce((a, b) => a + b, 0);
+  if (total === 0) return [];
+
+  return Object.entries(totals)
+    .map(([lang, bytes]) => ({ lang, pct: (bytes / total) * 100 }))
+    .sort((a, b) => b.pct - a.pct)
+    .slice(0, 8);
+}
+
+/**
+ * Picks the top N non-fork repos by star count.
+ */
+export function topRepos(repos, n = 5) {
+  return [...repos]
+    .sort((a, b) => b.stargazers_count - a.stargazers_count)
+    .slice(0, n);
+}
+
+/**
+ * Counts public event types from the last 90 days.
+ * @returns {{ type: string, count: number }[]}
+ */
+export function analyzeActivity(events) {
+  const cutoff = Date.now() - 90 * 24 * 60 * 60 * 1000;
+  const counts = {};
+
+  for (const event of events) {
+    if (new Date(event.created_at).getTime() < cutoff) continue;
+    // Strip "Event" suffix: "PushEvent" → "Push"
+    const type = event.type.replace(/Event$/, '');
+    counts[type] = (counts[type] || 0) + 1;
+  }
+
+  return Object.entries(counts)
+    .map(([type, count]) => ({ type, count }))
+    .sort((a, b) => b.count - a.count)
+    .slice(0, 6);
+}
+
+export function fmt(n) {
+  return Number(n).toLocaleString();
+}

package/src/api.js

@@ -0,0 +1,37 @@
+const BASE = 'https://api.github.com';
+
+async function get(path, token) {
+  const headers = { Accept: 'application/vnd.github.v3+json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  const res = await fetch(`${BASE}${path}`, { headers });
+
+  if (res.status === 404) throw new Error('User not found');
+  if (res.status === 403) {
+    throw new Error('Rate limit hit — pass --token or set GITHUB_TOKEN to get 5,000 req/hr');
+  }
+  if (res.status === 401) throw new Error('Bad token — check your GITHUB_TOKEN');
+  if (!res.ok) throw new Error(`GitHub API error ${res.status}`);
+
+  return res.json();
+}
+
+export async function fetchUser(username, token) {
+  return get(`/users/${username}`, token);
+}
+
+export async function fetchRepos(username, token) {
+  return get(`/users/${username}/repos?sort=pushed&per_page=100`, token);
+}
+
+export async function fetchLanguages(owner, repo, token) {
+  try {
+    return await get(`/repos/${owner}/${repo}/languages`, token);
+  } catch {
+    return {};
+  }
+}
+
+export async function fetchEvents(username, token) {
+  return get(`/users/${username}/events/public?per_page=100`, token);
+}

package/src/display.js

@@ -0,0 +1,110 @@
+import chalk from 'chalk';
+import { fmt } from './analyze.js';
+
+const COL = 72; // max output width
+
+// ─── Primitives ──────────────────────────────────────────────────────────────
+
+function rule(label) {
+  const pad = COL - label.length - 2;
+  console.log('\n' + chalk.cyan(label) + ' ' + chalk.dim('─'.repeat(pad)));
+}
+
+function kv(label, value, width = 18) {
+  const pad = ' '.repeat(Math.max(0, width - label.length));
+  console.log('  ' + chalk.dim(label + pad) + chalk.yellow(value));
+}
+
+/**
+ * Renders a horizontal bar for a percentage value.
+ *
+ * TODO: Implement this function.
+ *
+ * @param {number} pct     The item's percentage (0–100)
+ * @param {number} maxPct  The largest percentage in the dataset (used to scale)
+ * @param {number} width   Total character width of the bar (filled + empty)
+ * @returns {string}       A bar string like "████████░░░░░░░░"
+ *
+ * Hints to consider:
+ *  - How many '█' chars should appear? Scale pct relative to maxPct.
+ *  - Fill the rest with '░' so every bar is the same total width.
+ *  - Math.round() prevents fractional char counts.
+ *  - What should you return if pct is 0?
+ */
+function renderBar(pct, maxPct, width) {
+  if (maxPct === 0) return '░'.repeat(width);
+  const filled = Math.round((pct / maxPct) * width);
+  return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+
+// ─── Sections ────────────────────────────────────────────────────────────────
+
+export function renderProfile(user) {
+  const joined = new Date(user.created_at).getFullYear();
+  const name = user.name ? `${user.login}  ${chalk.bold(user.name)}` : user.login;
+
+  console.log('\n' + chalk.bold.white('  ' + name));
+
+  if (user.bio) console.log('  ' + chalk.dim(user.bio));
+
+  const loc = user.location ? `📍 ${user.location}  ` : '';
+  const blog = user.blog ? `🔗 ${user.blog}  ` : '';
+  if (loc || blog) console.log('  ' + chalk.dim(loc + blog));
+
+  console.log(
+    '\n  ' +
+      [
+        chalk.white(`${fmt(user.public_repos)} repos`),
+        chalk.white(`${fmt(user.followers)} followers`),
+        chalk.white(`${fmt(user.following)} following`),
+        chalk.dim(`since ${joined}`),
+      ].join(chalk.dim('  ·  '))
+  );
+}
+
+export function renderLanguages(languages) {
+  if (languages.length === 0) return;
+  rule('Languages');
+
+  const maxPct = languages[0].pct; // already sorted descending
+  const BAR_WIDTH = 24;
+  const labelWidth = Math.max(...languages.map((l) => l.lang.length)) + 2;
+
+  for (const { lang, pct } of languages) {
+    const label = lang.padEnd(labelWidth);
+    const bar = renderBar(pct, maxPct, BAR_WIDTH);
+    const pctStr = pct.toFixed(1).padStart(5) + '%';
+    console.log(`  ${chalk.white(label)} ${chalk.green(bar)} ${chalk.dim(pctStr)}`);
+  }
+}
+
+export function renderRepos(repos) {
+  if (repos.length === 0) return;
+  rule('Top Repositories');
+
+  const nameWidth = Math.max(...repos.map((r) => r.name.length)) + 2;
+
+  for (const repo of repos) {
+    const name = repo.name.padEnd(nameWidth);
+    const stars = chalk.yellow(`★ ${fmt(repo.stargazers_count).padStart(5)}`);
+    const forks = chalk.dim(`⑂ ${fmt(repo.forks_count).padStart(5)}`);
+    const lang = repo.language ? chalk.cyan(repo.language) : chalk.dim('—');
+    const forked = repo.fork ? chalk.dim(' fork') : '';
+    console.log(`  ${chalk.white(name)} ${stars}  ${forks}  ${lang}${forked}`);
+  }
+}
+
+export function renderActivity(activity) {
+  if (activity.length === 0) return;
+  rule('Activity  (last 90 days)');
+
+  const maxCount = activity[0].count;
+  const BAR_WIDTH = 28;
+  const labelWidth = Math.max(...activity.map((a) => a.type.length)) + 2;
+
+  for (const { type, count } of activity) {
+    const label = type.padEnd(labelWidth);
+    const bar = renderBar(count, maxCount, BAR_WIDTH);
+    console.log(`  ${chalk.white(label)} ${chalk.blue(bar)} ${chalk.dim(count)}`);
+  }
+}

package/src/index.js

@@ -0,0 +1,47 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import { fetchUser, fetchRepos, fetchLanguages, fetchEvents } from './api.js';
+import { analyzeLanguages, topRepos, analyzeActivity } from './analyze.js';
+import { renderProfile, renderLanguages, renderRepos, renderActivity } from './display.js';
+
+export async function analyzeProfile(username, { token, top = 5 }) {
+  const resolvedToken = token || process.env.GITHUB_TOKEN;
+  const spinner = ora(`Fetching ${chalk.cyan(username)}`).start();
+
+  try {
+    // 1. User profile
+    spinner.text = `Fetching profile for ${chalk.cyan(username)}`;
+    const user = await fetchUser(username, resolvedToken);
+
+    // 2. Repos + languages (in parallel, capped at 30 repos to stay within rate limits)
+    spinner.text = 'Fetching repositories…';
+    const repos = await fetchRepos(username, resolvedToken);
+    const sample = repos.slice(0, 30);
+
+    spinner.text = 'Analyzing languages…';
+    const langMaps = await Promise.all(
+      sample.map((r) => fetchLanguages(r.owner.login, r.name, resolvedToken))
+    );
+
+    // 3. Recent public events
+    spinner.text = 'Fetching recent activity…';
+    let events = [];
+    try {
+      events = await fetchEvents(username, resolvedToken);
+    } catch {
+      // Events endpoint can be empty for private accounts — not fatal
+    }
+
+    spinner.succeed(chalk.green(`${username} — done`));
+
+    // ── Render ──────────────────────────────────────────────────────────────
+    renderProfile(user);
+    renderLanguages(analyzeLanguages(langMaps));
+    renderRepos(topRepos(repos, Number(top)));
+    renderActivity(analyzeActivity(events));
+    console.log('');
+  } catch (err) {
+    spinner.fail(chalk.red(err.message));
+    process.exit(1);
+  }
+}