@urmzd/github-insights 2.0.0

package/src/parsers.ts

@@ -0,0 +1,146 @@
+import * as toml from "smol-toml";
+import type { PackageParser } from "./types.js";
+
+export const NodePackageParser: PackageParser = {
+  filenames: ["package.json"],
+  parseDependencies(text) {
+    try {
+      const pkg = JSON.parse(text);
+      return [
+        ...Object.keys(pkg.dependencies || {}),
+        ...Object.keys(pkg.devDependencies || {}),
+      ];
+    } catch {
+      console.warn("Warning: failed to parse package.json");
+      return [];
+    }
+  },
+};
+
+export const CargoParser: PackageParser = {
+  filenames: ["Cargo.toml"],
+  parseDependencies(text) {
+    try {
+      const parsed = toml.parse(text);
+      const tables: string[] = [
+        "dependencies",
+        "dev-dependencies",
+        "build-dependencies",
+      ];
+      const deps: string[] = [];
+      for (const table of tables) {
+        const section = parsed[table];
+        if (section && typeof section === "object") {
+          deps.push(...Object.keys(section as Record<string, unknown>));
+        }
+      }
+      return deps;
+    } catch {
+      console.warn("Warning: failed to parse Cargo.toml");
+      return [];
+    }
+  },
+};
+
+export const GoModParser: PackageParser = {
+  filenames: ["go.mod"],
+  parseDependencies(text) {
+    try {
+      const deps: string[] = [];
+      let inRequire = false;
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("require (")) {
+          inRequire = true;
+          continue;
+        }
+        if (trimmed === ")") {
+          inRequire = false;
+          continue;
+        }
+        if (inRequire && trimmed && !trimmed.startsWith("//")) {
+          const modulePath = trimmed.split(/\s/)[0];
+          const segments = modulePath.split("/");
+          deps.push(segments[segments.length - 1]);
+        }
+      }
+      return deps;
+    } catch {
+      console.warn("Warning: failed to parse go.mod");
+      return [];
+    }
+  },
+};
+
+export const PyprojectParser: PackageParser = {
+  filenames: ["pyproject.toml"],
+  parseDependencies(text) {
+    try {
+      const parsed = toml.parse(text);
+      const deps: string[] = [];
+
+      // PEP 621: project.dependencies array
+      const project = parsed.project as { dependencies?: string[] } | undefined;
+      if (project?.dependencies) {
+        for (const raw of project.dependencies) {
+          const name = raw.split(/[>=<!~;\s[]/)[0].trim();
+          if (name) deps.push(name);
+        }
+      }
+
+      // Poetry: tool.poetry.dependencies table
+      const tool = parsed.tool as
+        | { poetry?: { dependencies?: Record<string, unknown> } }
+        | undefined;
+      const poetryDeps = tool?.poetry?.dependencies;
+      if (poetryDeps) {
+        for (const name of Object.keys(poetryDeps)) {
+          if (name !== "python") deps.push(name);
+        }
+      }
+
+      return deps;
+    } catch {
+      console.warn("Warning: failed to parse pyproject.toml");
+      return [];
+    }
+  },
+};
+
+export const RequirementsTxtParser: PackageParser = {
+  filenames: ["requirements.txt"],
+  parseDependencies(text) {
+    try {
+      return text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(
+          (line) => line && !line.startsWith("#") && !line.startsWith("-"),
+        )
+        .map((line) => line.split(/[>=<!~;\s[]/)[0].trim())
+        .filter(Boolean);
+    } catch {
+      console.warn("Warning: failed to parse requirements.txt");
+      return [];
+    }
+  },
+};
+
+export const PARSERS: PackageParser[] = [
+  NodePackageParser,
+  CargoParser,
+  GoModParser,
+  PyprojectParser,
+  RequirementsTxtParser,
+];
+
+// Build lookup from filenames → parser (derived from PARSERS, not manually maintained)
+const PARSER_MAP = new Map<string, PackageParser>();
+for (const parser of PARSERS) {
+  for (const filename of parser.filenames) {
+    PARSER_MAP.set(filename, parser);
+  }
+}
+
+export const parseManifest = (filename: string, text: string): string[] =>
+  PARSER_MAP.get(filename)?.parseDependencies(text) ?? [];

package/src/readme.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, it } from "vitest";
+import { generateReadme } from "./readme.js";
+
+describe("generateReadme", () => {
+  it("renders minimal readme (name + single SVG)", () => {
+    const result = generateReadme({
+      name: "octocat",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).toContain(
+      "# octocat\n\n![GitHub Metrics](metrics/index.svg)",
+    );
+    expect(result).toMatch(
+      /Last generated on \d{4}-\d{2}-\d{2} using \[@urmzd\/github-insights\]/,
+    );
+  });
+
+  it("includes pronunciation when set", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      pronunciation: "/ˈʊrm.zəd/",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).toContain("# Urmzd <sub><i>(/ˈʊrm.zəd/)</i></sub>");
+  });
+
+  it("omits pronunciation when not set", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).not.toContain("<sub><i>");
+    expect(result).toContain("# Urmzd\n");
+  });
+
+  it("includes title as blockquote when set", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      title: "Senior Backend Engineer",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).toContain("> Senior Backend Engineer");
+  });
+
+  it("omits title when not set", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).not.toContain("> ");
+  });
+
+  it("includes preamble content when set", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      preamble: "Hello, I build things.",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).toContain("Hello, I build things.");
+  });
+
+  it("omits preamble when not set", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    // Only heading + SVG + attribution + trailing newline
+    expect(result).not.toContain("Hello");
+    expect(result).toContain("# Urmzd");
+    expect(result).toContain("![GitHub Metrics](metrics/index.svg)");
+  });
+
+  it("preamble is not wrapped in code fences", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      preamble: "Hello, I build things.",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).toContain("Hello, I build things.");
+    expect(result).not.toContain("```");
+  });
+
+  it("multi-paragraph preamble preserves structure", () => {
+    const preamble =
+      "First paragraph.\n\nSecond paragraph.\n\nThird paragraph.";
+    const result = generateReadme({
+      name: "Urmzd",
+      preamble: preamble,
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).toContain(preamble);
+    expect(result).toContain(`# Urmzd\n\n${preamble}\n\n![GitHub Metrics]`);
+  });
+
+  it("preamble with markdown features inserted raw", () => {
+    const preamble =
+      "I am **bold** and have [![Badge](https://img.shields.io)](https://example.com) and a [link](https://example.com).";
+    const result = generateReadme({
+      name: "Urmzd",
+      preamble: preamble,
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).toContain("**bold**");
+    expect(result).toContain(
+      "[![Badge](https://img.shields.io)](https://example.com)",
+    );
+    expect(result).toContain("[link](https://example.com)");
+    expect(result).not.toContain("```");
+  });
+
+  it("preamble separated from adjacent sections by blank lines", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      pronunciation: "/ˈʊrm.zəd/",
+      title: "Senior Backend Engineer",
+      preamble: "Welcome to my profile!",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+      bio: "Building tools for developers",
+    });
+    expect(result).toContain(
+      "> Senior Backend Engineer\n\nWelcome to my profile!",
+    );
+    expect(result).toContain(
+      "Welcome to my profile!\n\n![GitHub Metrics](metrics/index.svg)",
+    );
+  });
+
+  it("includes bio footer when set", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      bio: "Building tools for developers",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).toContain("---\n\n<sub>Building tools for developers</sub>");
+  });
+
+  it("omits bio when not set", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result).not.toContain("---");
+    // Should only have the attribution <sub>, not a bio <sub>
+    const subMatches = result.match(/<sub>/g) || [];
+    expect(subMatches).toHaveLength(1);
+    expect(result).toContain("Last generated on");
+  });
+
+  it("renders multiple SVGs individually", () => {
+    const result = generateReadme({
+      name: "Urmzd",
+      svgs: [
+        { label: "Languages", path: "metrics/metrics-languages.svg" },
+        { label: "Projects", path: "metrics/metrics-projects.svg" },
+        { label: "Expertise", path: "metrics/metrics-expertise.svg" },
+      ],
+    });
+    expect(result).toContain("![Languages](metrics/metrics-languages.svg)");
+    expect(result).toContain("![Projects](metrics/metrics-projects.svg)");
+    expect(result).toContain("![Expertise](metrics/metrics-expertise.svg)");
+  });
+
+  it("renders all sections combined", () => {
+    const result = generateReadme({
+      name: "Urmzd Maharramoff",
+      pronunciation: "/ˈʊrm.zəd/",
+      title: "Senior Backend Engineer",
+      preamble: "Welcome to my profile!",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+      bio: "Building tools for developers",
+    });
+    expect(result).toContain(
+      "# Urmzd Maharramoff <sub><i>(/ˈʊrm.zəd/)</i></sub>",
+    );
+    expect(result).toContain("> Senior Backend Engineer");
+    expect(result).toContain("Welcome to my profile!");
+    expect(result).toContain("![GitHub Metrics](metrics/index.svg)");
+    expect(result).toContain("---\n\n<sub>Building tools for developers</sub>");
+  });
+
+  it("ends with a trailing newline", () => {
+    const result = generateReadme({
+      name: "octocat",
+      svgs: [{ label: "GitHub Metrics", path: "metrics/index.svg" }],
+    });
+    expect(result.endsWith("\n")).toBe(true);
+    expect(result.endsWith("\n\n")).toBe(false);
+  });
+});

package/src/readme.ts

@@ -0,0 +1,70 @@
+import { readFileSync } from "node:fs";
+import type { SvgEmbed } from "./types.js";
+
+export type { SvgEmbed };
+
+export interface ReadmeOptions {
+  name: string;
+  pronunciation?: string;
+  title?: string;
+  preamble?: string;
+  svgs: SvgEmbed[];
+  bio?: string;
+}
+
+export function generateReadme(options: ReadmeOptions): string {
+  const parts: string[] = [];
+
+  // Heading
+  if (options.pronunciation) {
+    parts.push(
+      `# ${options.name} <sub><i>(${options.pronunciation})</i></sub>`,
+    );
+  } else {
+    parts.push(`# ${options.name}`);
+  }
+
+  // Title blockquote
+  if (options.title) {
+    parts.push(`> ${options.title}`);
+  }
+
+  // Preamble
+  if (options.preamble) {
+    parts.push(options.preamble);
+  }
+
+  // SVG embeds
+  for (const svg of options.svgs) {
+    parts.push(`![${svg.label}](${svg.path})`);
+  }
+
+  // Bio footer
+  if (options.bio) {
+    parts.push(`---\n\n<sub>${options.bio}</sub>`);
+  }
+
+  // Attribution
+  const now = new Date().toISOString().split("T")[0];
+  parts.push(
+    `<sub>Last generated on ${now} using [@urmzd/github-insights](https://github.com/urmzd/github-insights)</sub>`,
+  );
+
+  return `${parts.join("\n\n")}\n`;
+}
+
+export function loadPreamble(path?: string): string | undefined {
+  const filePath = path || "PREAMBLE.md";
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch (err: unknown) {
+    if (
+      err instanceof Error &&
+      "code" in err &&
+      (err as NodeJS.ErrnoException).code === "ENOENT"
+    ) {
+      return undefined;
+    }
+    throw err;
+  }
+}

package/src/svg-utils.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { escapeXml, truncate, wrapText } from "./svg-utils.js";
+
+describe("escapeXml", () => {
+  it("escapes & < > \" '", () => {
+    expect(escapeXml('Tom & Jerry <"hello"> it\'s')).toBe(
+      "Tom &amp; Jerry &lt;&quot;hello&quot;&gt; it&apos;s",
+    );
+  });
+
+  it('returns "" for null', () => {
+    expect(escapeXml(null)).toBe("");
+  });
+
+  it('returns "" for undefined', () => {
+    expect(escapeXml(undefined)).toBe("");
+  });
+
+  it('returns "" for empty string', () => {
+    expect(escapeXml("")).toBe("");
+  });
+
+  it("returns plain string unchanged", () => {
+    expect(escapeXml("hello world")).toBe("hello world");
+  });
+});
+
+describe("truncate", () => {
+  it("returns short string untouched", () => {
+    expect(truncate("hello", 10)).toBe("hello");
+  });
+
+  it("truncates long string with ellipsis", () => {
+    expect(truncate("abcdefghij", 5)).toBe("abcd\u2026");
+  });
+
+  it('returns "" for null', () => {
+    expect(truncate(null, 10)).toBe("");
+  });
+
+  it('returns "" for undefined', () => {
+    expect(truncate(undefined, 10)).toBe("");
+  });
+
+  it("returns exact-length string untouched", () => {
+    expect(truncate("abcde", 5)).toBe("abcde");
+  });
+});
+
+describe("wrapText", () => {
+  it("returns single line when text fits", () => {
+    expect(wrapText("short text", 30)).toEqual(["short text"]);
+  });
+
+  it("wraps at word boundary", () => {
+    const lines = wrapText("hello world foo bar", 12);
+    expect(lines.length).toBeGreaterThan(1);
+    for (const line of lines) {
+      expect(line.length).toBeLessThanOrEqual(12);
+    }
+  });
+
+  it("returns [] for empty string", () => {
+    expect(wrapText("", 20)).toEqual([]);
+  });
+});

package/src/svg-utils.ts

@@ -0,0 +1,33 @@
+export const escapeXml = (str: string | null | undefined): string => {
+  if (!str) return "";
+  return str
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+};
+
+export const truncate = (
+  str: string | null | undefined,
+  max: number,
+): string => {
+  if (!str) return "";
+  return str.length > max ? `${str.slice(0, max - 1)}\u2026` : str;
+};
+
+export const wrapText = (text: string, maxChars: number): string[] => {
+  const words = text.split(/\s+/);
+  const lines: string[] = [];
+  let current = "";
+  for (const word of words) {
+    if (current && `${current} ${word}`.length > maxChars) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = current ? `${current} ${word}` : word;
+    }
+  }
+  if (current) lines.push(current);
+  return lines;
+};