@urmzd/github-insights 2.0.0

package/src/metrics.ts

@@ -0,0 +1,365 @@
+import { renderContributionCalendar } from "./components/contribution-calendar.js";
+import { renderContributionCards } from "./components/contribution-cards.js";
+import { renderDonutChart } from "./components/donut-chart.js";
+import { renderProjectCards } from "./components/project-cards.js";
+import { renderStatCards } from "./components/stat-cards.js";
+import { renderTechHighlights } from "./components/tech-highlights.js";
+import { parseManifest } from "./parsers.js";
+import type {
+  ContributionData,
+  LanguageItem,
+  ManifestMap,
+  ProjectItem,
+  ProjectStatus,
+  RepoClassificationInput,
+  RepoClassificationOutput,
+  RepoNode,
+  SectionDef,
+  TechHighlight,
+} from "./types.js";
+
+// ── Category Sets ───────────────────────────────────────────────────────────
+
+const EXCLUDED_LANGUAGES = new Set(["Jupyter Notebook"]);
+
+// ── Section keys ────────────────────────────────────────────────────────────
+
+export const SECTION_KEYS: Record<string, string> = {
+  pulse: "metrics-pulse.svg",
+  languages: "metrics-languages.svg",
+  expertise: "metrics-expertise.svg",
+  projects: "metrics-complexity.svg",
+  contributions: "metrics-contributions.svg",
+  calendar: "metrics-calendar.svg",
+};
+
+// ── Aggregation ─────────────────────────────────────────────────────────────
+
+export const aggregateLanguages = (repos: RepoNode[]): LanguageItem[] => {
+  const langBytes = new Map<string, number>();
+  const langColors = new Map<string, string>();
+
+  for (const repo of repos) {
+    for (const edge of repo.languages?.edges || []) {
+      const name = edge.node.name;
+      if (EXCLUDED_LANGUAGES.has(name)) continue;
+      langBytes.set(name, (langBytes.get(name) || 0) + edge.size);
+      if (!langColors.has(name)) langColors.set(name, edge.node.color);
+    }
+  }
+
+  const total = [...langBytes.values()].reduce((a, b) => a + b, 0);
+  return [...langBytes.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([name, bytes]) => ({
+      name,
+      value: bytes,
+      percent: ((bytes / total) * 100).toFixed(1),
+      color: langColors.get(name) || "#8b949e",
+    }));
+};
+
+// ── Dependency & Topic Collection ────────────────────────────────────────────
+
+export const collectAllDependencies = (
+  repos: RepoNode[],
+  manifests: ManifestMap,
+): string[] => {
+  const seen = new Set<string>();
+  for (const repo of repos) {
+    const files = manifests.get(repo.name) || {};
+    for (const [filename, text] of Object.entries(files)) {
+      for (const dep of parseManifest(filename, text)) {
+        seen.add(dep);
+      }
+    }
+  }
+  return [...seen].sort();
+};
+
+export const collectAllTopics = (repos: RepoNode[]): string[] => {
+  const seen = new Set<string>();
+  for (const repo of repos) {
+    for (const node of repo.repositoryTopics?.nodes || []) {
+      seen.add(node.topic.name);
+    }
+  }
+  return [...seen].sort();
+};
+
+// ── Project complexity scoring ──────────────────────────────────────────────
+
+const repoLanguages = (repo: RepoNode): string[] =>
+  repo.languages.edges.map((e) => e.node.name);
+
+export const complexityScore = (repo: RepoNode): number => {
+  const langCount = repo.languages.edges.length;
+  const sizeMb = repo.diskUsage / 1024;
+  const stars = repo.stargazerCount;
+  const topics = repo.repositoryTopics.nodes.length;
+
+  // Weighted sum: language diversity matters most, then code size, then
+  // social proof (stars) and topic breadth as tie-breakers.
+  return (
+    langCount * 10 +
+    Math.min(sizeMb, 50) * 2 +
+    Math.log2(stars + 1) * 3 +
+    topics * 2
+  );
+};
+
+const toProjectItem = (repo: RepoNode): ProjectItem => ({
+  name: repo.name,
+  url: repo.url,
+  description: repo.description || "",
+  stars: repo.stargazerCount,
+  languageCount: repo.languages.edges.length,
+  codeSize: repo.diskUsage,
+  languages: repoLanguages(repo),
+});
+
+// ── Top Projects by Stars ───────────────────────────────────────────────────
+
+export const getTopProjectsByStars = (repos: RepoNode[]): ProjectItem[] =>
+  [...repos]
+    .sort((a, b) => b.stargazerCount - a.stargazerCount)
+    .slice(0, 5)
+    .map(toProjectItem);
+
+// ── Top Projects by Complexity ─────────────────────────────────────────────
+
+export const getTopProjectsByComplexity = (
+  repos: RepoNode[],
+): ProjectItem[] => {
+  const sorted = [...repos].sort(
+    (a, b) => complexityScore(b) - complexityScore(a),
+  );
+  for (const repo of sorted) {
+    console.info(
+      `[complexity] ${repo.name}: ${complexityScore(repo).toFixed(1)} (${repo.languages.edges.length} langs, ${repo.diskUsage}KB)`,
+    );
+  }
+  return sorted.map(toProjectItem);
+};
+
+// ── Project classification ──────────────────────────────────────────────────
+
+const ACTIVE_COMMIT_THRESHOLD = 5;
+
+export const buildClassificationInputs = (
+  repos: RepoNode[],
+  contributionData: ContributionData,
+): RepoClassificationInput[] => {
+  const commitMap = new Map<string, number>();
+  for (const entry of contributionData.commitContributionsByRepository || []) {
+    commitMap.set(entry.repository.name, entry.contributions.totalCount);
+  }
+
+  return repos.map((repo) => ({
+    name: repo.name,
+    description: repo.description || "",
+    stars: repo.stargazerCount,
+    diskUsageKb: repo.diskUsage,
+    languages: repo.languages.edges.map((e) => e.node.name),
+    commitsLastYear: commitMap.get(repo.name) || 0,
+    createdAt: repo.createdAt,
+    pushedAt: repo.pushedAt,
+    topicCount: repo.repositoryTopics.nodes.length,
+  }));
+};
+
+const heuristicStatus = (
+  commits: number,
+  createdAt?: string,
+): ProjectStatus => {
+  const isYoung = createdAt
+    ? Date.now() - new Date(createdAt).getTime() < 6 * 30 * 24 * 60 * 60 * 1000
+    : false;
+
+  if (isYoung && commits >= ACTIVE_COMMIT_THRESHOLD) return "active";
+  if (commits > 0) return "maintained";
+  return "inactive";
+};
+
+export const splitProjectsByRecency = (
+  repos: RepoNode[],
+  contributionData: ContributionData,
+  aiClassifications?: RepoClassificationOutput[],
+): {
+  active: ProjectItem[];
+  maintained: ProjectItem[];
+  inactive: ProjectItem[];
+} => {
+  const commitMap = new Map<string, number>();
+  for (const entry of contributionData.commitContributionsByRepository || []) {
+    commitMap.set(entry.repository.name, entry.contributions.totalCount);
+  }
+
+  const aiMap = new Map<string, RepoClassificationOutput>();
+  if (aiClassifications) {
+    for (const c of aiClassifications) {
+      aiMap.set(c.name, c);
+    }
+  }
+
+  const activeRepos: RepoNode[] = [];
+  const maintainedRepos: RepoNode[] = [];
+  const inactiveRepos: RepoNode[] = [];
+
+  for (const repo of repos) {
+    const commits = commitMap.get(repo.name) || 0;
+    const aiEntry = aiMap.get(repo.name);
+    const status = aiEntry?.status || heuristicStatus(commits, repo.createdAt);
+    const source = aiEntry ? "ai" : "heuristic";
+
+    if (status === "active") {
+      activeRepos.push(repo);
+    } else if (status === "maintained") {
+      maintainedRepos.push(repo);
+    } else {
+      inactiveRepos.push(repo);
+    }
+
+    console.info(
+      `[${status.padEnd(10)}] ${repo.name} (${commits} commits, complexity=${complexityScore(repo).toFixed(1)}, source=${source})`,
+    );
+  }
+
+  console.info(
+    `Split: ${activeRepos.length} active, ${maintainedRepos.length} maintained, ${inactiveRepos.length} inactive`,
+  );
+
+  const sortByComplexity = (a: RepoNode, b: RepoNode) =>
+    complexityScore(b) - complexityScore(a);
+
+  const toProjectItemWithSummary = (repo: RepoNode): ProjectItem => ({
+    ...toProjectItem(repo),
+    summary: aiMap.get(repo.name)?.summary || undefined,
+    category: aiMap.get(repo.name)?.category || undefined,
+  });
+
+  const active: ProjectItem[] = activeRepos
+    .sort(sortByComplexity)
+    .map(toProjectItemWithSummary);
+  const maintained: ProjectItem[] = maintainedRepos
+    .sort(sortByComplexity)
+    .map(toProjectItemWithSummary);
+  const inactive: ProjectItem[] = inactiveRepos
+    .sort(sortByComplexity)
+    .map(toProjectItemWithSummary);
+
+  return { active, maintained, inactive };
+};
+
+// ── Section definitions ─────────────────────────────────────────────────────
+
+export const buildSections = ({
+  languages,
+  techHighlights,
+  projects,
+  contributionData,
+}: {
+  languages: LanguageItem[];
+  techHighlights: TechHighlight[];
+  projects: ProjectItem[];
+  contributionData: ContributionData;
+}): SectionDef[] => {
+  const sections: SectionDef[] = [];
+
+  // 1. At a Glance
+  sections.push({
+    filename: "metrics-pulse.svg",
+    title: "At a Glance",
+    subtitle: "Contribution activity over the past year",
+    renderBody: (y: number) => {
+      const stats = [
+        {
+          label: "COMMITS",
+          value:
+            contributionData.contributions.totalCommitContributions.toLocaleString(),
+        },
+        {
+          label: "PRS",
+          value:
+            contributionData.contributions.totalPullRequestContributions.toLocaleString(),
+        },
+        {
+          label: "REVIEWS",
+          value:
+            contributionData.contributions.totalPullRequestReviewContributions.toLocaleString(),
+        },
+        {
+          label: "REPOS",
+          value:
+            contributionData.contributions.totalRepositoriesWithContributedCommits.toLocaleString(),
+        },
+      ];
+      return renderStatCards(stats, y);
+    },
+  });
+
+  // 2. Languages
+  sections.push({
+    filename: "metrics-languages.svg",
+    title: "Languages",
+    subtitle: "By bytes of code across all public repos",
+    renderBody: (y: number) => renderDonutChart(languages, y),
+  });
+
+  // 3. Expertise
+  if (techHighlights.length > 0) {
+    sections.push({
+      filename: "metrics-expertise.svg",
+      title: "Expertise",
+      subtitle:
+        "Curated from dependencies, topics, and languages via AI analysis",
+      renderBody: (y: number) => renderTechHighlights(techHighlights, y),
+    });
+  }
+
+  // 4. Signature Projects
+  sections.push({
+    filename: "metrics-complexity.svg",
+    title: "Signature Projects",
+    subtitle: "Top projects by technical complexity",
+    renderBody: (y: number) => renderProjectCards(projects, y),
+  });
+
+  // 5. Contribution Calendar
+  if (contributionData.contributionCalendar) {
+    const calendarData = contributionData.contributionCalendar;
+    sections.push({
+      filename: "metrics-calendar.svg",
+      title: "Contribution Calendar",
+      subtitle: `${calendarData.totalContributions.toLocaleString()} contributions in the last year`,
+      renderBody: (y: number) => renderContributionCalendar(calendarData, y),
+    });
+  }
+
+  // 6. Open Source Contributions
+  if (contributionData.externalRepos.nodes.length > 0) {
+    sections.push({
+      filename: "metrics-contributions.svg",
+      title: "Open Source Contributions",
+      subtitle: "External repositories contributed to (all time)",
+      renderBody: (y: number) => {
+        const repos = contributionData.externalRepos.nodes.slice(0, 5);
+        const highlights = repos.map((r) => ({
+          project: r.nameWithOwner,
+          detail: [
+            r.stargazerCount > 0
+              ? `\u2605 ${r.stargazerCount.toLocaleString()}`
+              : null,
+            r.primaryLanguage?.name,
+          ]
+            .filter(Boolean)
+            .join(" \u00b7 "),
+        }));
+        return renderContributionCards(highlights, y);
+      },
+    });
+  }
+
+  return sections;
+};

package/src/parsers.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, it } from "vitest";
+import {
+  CargoParser,
+  GoModParser,
+  NodePackageParser,
+  PARSERS,
+  PyprojectParser,
+  parseManifest,
+  RequirementsTxtParser,
+} from "./parsers.js";
+
+describe("NodePackageParser", () => {
+  it("returns both deps and devDeps", () => {
+    const json = JSON.stringify({
+      dependencies: { react: "^18.0.0", next: "^14.0.0" },
+      devDependencies: { vitest: "^2.0.0" },
+    });
+    expect(NodePackageParser.parseDependencies(json)).toEqual([
+      "react",
+      "next",
+      "vitest",
+    ]);
+  });
+
+  it("returns only dependencies when devDependencies is missing", () => {
+    const json = JSON.stringify({ dependencies: { express: "^4.0.0" } });
+    expect(NodePackageParser.parseDependencies(json)).toEqual(["express"]);
+  });
+
+  it("returns only devDependencies when dependencies is missing", () => {
+    const json = JSON.stringify({ devDependencies: { jest: "^29.0.0" } });
+    expect(NodePackageParser.parseDependencies(json)).toEqual(["jest"]);
+  });
+
+  it("returns [] for invalid JSON", () => {
+    expect(NodePackageParser.parseDependencies("not json")).toEqual([]);
+  });
+
+  it("returns [] for empty object", () => {
+    expect(NodePackageParser.parseDependencies("{}")).toEqual([]);
+  });
+});
+
+describe("CargoParser", () => {
+  it("parses [dependencies] and [dev-dependencies]", () => {
+    const toml = `[dependencies]
+serde = "1.0"
+tokio = { version = "1", features = ["full"] }
+
+[dev-dependencies]
+criterion = "0.5"
+`;
+    expect(CargoParser.parseDependencies(toml)).toEqual([
+      "serde",
+      "tokio",
+      "criterion",
+    ]);
+  });
+
+  it("stops collecting when hitting a non-deps section", () => {
+    const toml = `[dependencies]
+serde = "1.0"
+
+[package]
+name = "myapp"
+version = "0.1.0"
+`;
+    expect(CargoParser.parseDependencies(toml)).toEqual(["serde"]);
+  });
+
+  it("ignores comments", () => {
+    const toml = `[dependencies]
+# this is a comment
+serde = "1.0"
+`;
+    expect(CargoParser.parseDependencies(toml)).toEqual(["serde"]);
+  });
+
+  it("handles inline table syntax", () => {
+    const toml = `[dependencies]
+tokio = { version = "1", features = ["full"] }
+`;
+    expect(CargoParser.parseDependencies(toml)).toEqual(["tokio"]);
+  });
+});
+
+describe("GoModParser", () => {
+  it("extracts last path segment from require block", () => {
+    const gomod = `module example.com/myapp
+
+go 1.21
+
+require (
+	github.com/gin-gonic/gin v1.9.1
+	github.com/stretchr/testify v1.8.4
+)
+`;
+    expect(GoModParser.parseDependencies(gomod)).toEqual(["gin", "testify"]);
+  });
+
+  it("ignores comments in require block", () => {
+    const gomod = `module example.com/myapp
+
+require (
+	// indirect dependency
+	github.com/gin-gonic/gin v1.9.1
+)
+`;
+    expect(GoModParser.parseDependencies(gomod)).toEqual(["gin"]);
+  });
+
+  it("returns [] when no require block", () => {
+    expect(
+      GoModParser.parseDependencies("module example.com/myapp\n\ngo 1.21\n"),
+    ).toEqual([]);
+  });
+});
+
+describe("PyprojectParser", () => {
+  it("parses PEP 621 dependencies array", () => {
+    const toml = `[project]
+name = "myapp"
+dependencies = [
+  "fastapi>=0.100.0",
+  "uvicorn[standard]>=0.23.0",
+]
+`;
+    expect(PyprojectParser.parseDependencies(toml)).toEqual([
+      "fastapi",
+      "uvicorn",
+    ]);
+  });
+
+  it("parses Poetry [tool.poetry.dependencies]", () => {
+    const toml = `[tool.poetry.dependencies]
+python = "^3.11"
+django = "^4.2"
+celery = "^5.3"
+`;
+    expect(PyprojectParser.parseDependencies(toml)).toEqual([
+      "django",
+      "celery",
+    ]);
+  });
+
+  it("strips version specifiers", () => {
+    const toml = `[project]
+dependencies = [
+  "requests>=2.28,<3",
+  "pydantic~=2.0",
+]
+`;
+    const result = PyprojectParser.parseDependencies(toml);
+    expect(result).toEqual(["requests", "pydantic"]);
+  });
+
+  it("excludes python from Poetry deps", () => {
+    const toml = `[tool.poetry.dependencies]
+python = "^3.11"
+flask = "^2.3"
+`;
+    expect(PyprojectParser.parseDependencies(toml)).toEqual(["flask"]);
+  });
+});
+
+describe("RequirementsTxtParser", () => {
+  it("strips version specifiers", () => {
+    const txt = `requests>=2.28.0
+flask==2.3.3
+numpy~=1.24
+`;
+    expect(RequirementsTxtParser.parseDependencies(txt)).toEqual([
+      "requests",
+      "flask",
+      "numpy",
+    ]);
+  });
+
+  it("ignores comments and blank lines", () => {
+    const txt = `# comment
+requests
+
+flask
+`;
+    expect(RequirementsTxtParser.parseDependencies(txt)).toEqual([
+      "requests",
+      "flask",
+    ]);
+  });
+
+  it("ignores flags like -r and -e", () => {
+    const txt = `-r base.txt
+-e git+https://example.com
+requests
+`;
+    expect(RequirementsTxtParser.parseDependencies(txt)).toEqual(["requests"]);
+  });
+
+  it("returns [] for empty input", () => {
+    expect(RequirementsTxtParser.parseDependencies("")).toEqual([]);
+  });
+});
+
+describe("PARSERS", () => {
+  it("covers all expected filenames", () => {
+    const allFilenames = PARSERS.flatMap((p) => p.filenames).sort();
+    expect(allFilenames).toEqual([
+      "Cargo.toml",
+      "go.mod",
+      "package.json",
+      "pyproject.toml",
+      "requirements.txt",
+    ]);
+  });
+});
+
+describe("parseManifest", () => {
+  it("dispatches to NodePackageParser for package.json", () => {
+    const json = JSON.stringify({ dependencies: { react: "^18" } });
+    expect(parseManifest("package.json", json)).toEqual(["react"]);
+  });
+
+  it("dispatches to CargoParser for Cargo.toml", () => {
+    const toml = '[dependencies]\nserde = "1.0"\n';
+    expect(parseManifest("Cargo.toml", toml)).toEqual(["serde"]);
+  });
+
+  it("dispatches to GoModParser for go.mod", () => {
+    const gomod = "module x\nrequire (\n\tgithub.com/foo/bar v1.0\n)\n";
+    expect(parseManifest("go.mod", gomod)).toEqual(["bar"]);
+  });
+
+  it("dispatches to PyprojectParser for pyproject.toml", () => {
+    const toml = '[project]\ndependencies = [\n  "flask",\n]\n';
+    expect(parseManifest("pyproject.toml", toml)).toEqual(["flask"]);
+  });
+
+  it("dispatches to RequirementsTxtParser for requirements.txt", () => {
+    expect(parseManifest("requirements.txt", "requests\n")).toEqual([
+      "requests",
+    ]);
+  });
+
+  it("returns [] for unknown filename", () => {
+    expect(parseManifest("Makefile", "all: build")).toEqual([]);
+  });
+});