chapa-cli 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# chapa-cli
+
+Merge GitHub EMU (Enterprise Managed User) contributions into your [Chapa](https://chapa.thecreativetoken.com) developer impact badge.
+
+If your employer uses GitHub EMU accounts, your work contributions are invisible on your personal profile. This CLI fetches your EMU stats and uploads them to Chapa so your badge reflects your full impact.
+
+## Usage
+
+```bash
+npx chapa-cli merge \
+  --handle your-personal-handle \
+  --emu-handle your-emu-handle
+```
+
+## Options
+
+| Flag | Description | Required |
+|------|-------------|----------|
+| `--handle <handle>` | Your personal GitHub handle | Yes |
+| `--emu-handle <handle>` | Your EMU GitHub handle | Yes |
+| `--emu-token <token>` | EMU GitHub token | No* |
+| `--token <token>` | Personal GitHub token | No* |
+| `--server <url>` | Chapa server URL | No |
+| `--version`, `-v` | Show version number | |
+| `--help`, `-h` | Show help message | |
+
+*Tokens are resolved in order: flag > environment variable > `gh auth token`.
+
+## Token setup
+
+Set tokens via environment variables to avoid passing them on every run:
+
+```bash
+export GITHUB_TOKEN=ghp_your_personal_token
+export GITHUB_EMU_TOKEN=ghp_your_emu_token
+```
+
+Tokens need the `read:user` scope at minimum.
+
+## How it works
+
+1. Fetches your last 90 days of activity from the EMU account via GitHub GraphQL API
+2. Uploads the stats (commits, PRs merged, reviews) to the Chapa server
+3. Your Chapa badge recalculates on next refresh, combining personal + EMU contributions
+
+## License
+
+MIT

package/dist/auth.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Token resolution for CLI.
+ *
+ * Priority: explicit flag → environment variable → null
+ * (gh auth token fallback is handled at the CLI orchestration level)
+ */
+export declare function resolveToken(flag: string | undefined, envVar: string): string | null;

package/dist/auth.js

@@ -0,0 +1,14 @@
+/**
+ * Token resolution for CLI.
+ *
+ * Priority: explicit flag → environment variable → null
+ * (gh auth token fallback is handled at the CLI orchestration level)
+ */
+export function resolveToken(flag, envVar) {
+    if (flag)
+        return flag;
+    const env = process.env[envVar]?.trim();
+    if (env)
+        return env;
+    return null;
+}

package/dist/auth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { resolveToken } from "./auth";
+describe("resolveToken", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it("returns explicit flag value when provided", () => {
+        const token = resolveToken("ghp_explicit", "GITHUB_TOKEN");
+        expect(token).toBe("ghp_explicit");
+    });
+    it("falls back to environment variable when flag is undefined", () => {
+        process.env.GITHUB_TOKEN = "ghp_from_env";
+        const token = resolveToken(undefined, "GITHUB_TOKEN");
+        expect(token).toBe("ghp_from_env");
+    });
+    it("trims whitespace from environment variable", () => {
+        process.env.GITHUB_TOKEN = "  ghp_padded  \n";
+        const token = resolveToken(undefined, "GITHUB_TOKEN");
+        expect(token).toBe("ghp_padded");
+    });
+    it("returns null when no flag and no env var", () => {
+        delete process.env.GITHUB_TOKEN;
+        const token = resolveToken(undefined, "GITHUB_TOKEN");
+        expect(token).toBeNull();
+    });
+});

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+export interface CliArgs {
+    command: "merge" | null;
+    handle?: string;
+    emuHandle?: string;
+    emuToken?: string;
+    token?: string;
+    server: string;
+}
+export declare function parseArgs(argv: string[]): CliArgs;

package/dist/cli.js

@@ -0,0 +1,28 @@
+import { parseArgs as nodeParseArgs } from "node:util";
+const DEFAULT_SERVER = "https://chapa.thecreativetoken.com";
+export function parseArgs(argv) {
+    // Extract positional command before flags
+    const positional = argv.find((a) => !a.startsWith("--"));
+    const command = positional === "merge" ? "merge" : null;
+    // Remove positional from argv for nodeParseArgs
+    const flagArgs = argv.filter((a) => a !== positional || a.startsWith("--"));
+    const { values } = nodeParseArgs({
+        args: flagArgs,
+        options: {
+            handle: { type: "string" },
+            "emu-handle": { type: "string" },
+            "emu-token": { type: "string" },
+            token: { type: "string" },
+            server: { type: "string", default: DEFAULT_SERVER },
+        },
+        strict: false,
+    });
+    return {
+        command,
+        handle: values.handle,
+        emuHandle: values["emu-handle"],
+        emuToken: values["emu-token"],
+        token: values.token,
+        server: values.server ?? DEFAULT_SERVER,
+    };
+}

package/dist/cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "vitest";
+import { parseArgs } from "./cli";
+describe("parseArgs", () => {
+    it("parses all required flags", () => {
+        const args = parseArgs([
+            "merge",
+            "--handle", "juan294",
+            "--emu-handle", "Juan_corp",
+        ]);
+        expect(args.command).toBe("merge");
+        expect(args.handle).toBe("juan294");
+        expect(args.emuHandle).toBe("Juan_corp");
+    });
+    it("parses optional flags", () => {
+        const args = parseArgs([
+            "merge",
+            "--handle", "juan294",
+            "--emu-handle", "Juan_corp",
+            "--emu-token", "ghp_emu",
+            "--token", "gho_personal",
+            "--server", "http://localhost:3001",
+        ]);
+        expect(args.emuToken).toBe("ghp_emu");
+        expect(args.token).toBe("gho_personal");
+        expect(args.server).toBe("http://localhost:3001");
+    });
+    it("uses default server URL when not provided", () => {
+        const args = parseArgs([
+            "merge",
+            "--handle", "juan294",
+            "--emu-handle", "Juan_corp",
+        ]);
+        expect(args.server).toBe("https://chapa.thecreativetoken.com");
+    });
+    it("returns null command when no positional arg", () => {
+        const args = parseArgs(["--handle", "juan294"]);
+        expect(args.command).toBeNull();
+    });
+    it("returns null command for unknown commands", () => {
+        const args = parseArgs(["unknown", "--handle", "juan294"]);
+        expect(args.command).toBeNull();
+    });
+});

package/dist/fetch-emu.d.ts

@@ -0,0 +1,2 @@
+import type { Stats90d } from "@chapa/shared";
+export declare function fetchEmuStats(login: string, emuToken: string): Promise<Stats90d | null>;

package/dist/fetch-emu.js

@@ -0,0 +1,157 @@
+// ---------------------------------------------------------------------------
+// GraphQL query (duplicated from apps/web/lib/github/queries.ts)
+// This is ~stable code; sharing via a common package is a future refactor.
+// ---------------------------------------------------------------------------
+const CONTRIBUTION_QUERY = `
+query($login: String!, $since: DateTime!, $until: DateTime!, $historySince: GitTimestamp!, $historyUntil: GitTimestamp!) {
+  user(login: $login) {
+    login
+    name
+    avatarUrl
+    contributionsCollection(from: $since, to: $until) {
+      contributionCalendar {
+        totalContributions
+        weeks {
+          contributionDays {
+            date
+            contributionCount
+          }
+        }
+      }
+      pullRequestContributions(first: 100) {
+        totalCount
+        nodes {
+          pullRequest {
+            additions
+            deletions
+            changedFiles
+            merged
+          }
+        }
+      }
+      pullRequestReviewContributions(first: 1) {
+        totalCount
+      }
+      issueContributions(first: 1) {
+        totalCount
+      }
+    }
+    repositories(first: 20, ownerAffiliations: [OWNER, COLLABORATOR], orderBy: {field: PUSHED_AT, direction: DESC}) {
+      totalCount
+      nodes {
+        nameWithOwner
+        defaultBranchRef {
+          target {
+            ... on Commit {
+              history(since: $historySince, until: $historyUntil) {
+                totalCount
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`;
+// ---------------------------------------------------------------------------
+// PR weight formula (duplicated from apps/web/lib/github/stats90d.ts)
+// ---------------------------------------------------------------------------
+function computePrWeight(pr) {
+    const w = 0.5 +
+        0.25 * Math.log(1 + pr.changedFiles) +
+        0.25 * Math.log(1 + pr.additions + pr.deletions);
+    return Math.min(w, 3.0);
+}
+// ---------------------------------------------------------------------------
+// Fetch EMU stats via GraphQL (requires EMU token with auth)
+// ---------------------------------------------------------------------------
+export async function fetchEmuStats(login, emuToken) {
+    const now = new Date();
+    const since = new Date(now);
+    since.setDate(since.getDate() - 90);
+    try {
+        const res = await fetch("https://api.github.com/graphql", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                Authorization: `Bearer ${emuToken}`,
+            },
+            body: JSON.stringify({
+                query: CONTRIBUTION_QUERY,
+                variables: {
+                    login,
+                    since: since.toISOString(),
+                    until: now.toISOString(),
+                    historySince: since.toISOString(),
+                    historyUntil: now.toISOString(),
+                },
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "(unreadable)");
+            console.error(`[cli] GraphQL HTTP ${res.status}: ${body}`);
+            return null;
+        }
+        const json = await res.json();
+        if (!json.data?.user)
+            return null;
+        const user = json.data.user;
+        const cc = user.contributionsCollection;
+        // Heatmap
+        const heatmapData = [];
+        for (const week of cc.contributionCalendar.weeks) {
+            for (const day of week.contributionDays) {
+                heatmapData.push({ date: day.date, count: day.contributionCount });
+            }
+        }
+        const activeDays = heatmapData.filter((d) => d.count > 0).length;
+        // PRs
+        const prNodes = cc.pullRequestContributions.nodes
+            .filter((n) => n != null && n.pullRequest != null)
+            .map((n) => n.pullRequest);
+        const mergedPRs = prNodes.filter((pr) => pr.merged);
+        const prsMergedCount = mergedPRs.length;
+        const prsMergedWeight = Math.min(mergedPRs.reduce((sum, pr) => sum + computePrWeight(pr), 0), 40);
+        const linesAdded = mergedPRs.reduce((sum, pr) => sum + pr.additions, 0);
+        const linesDeleted = mergedPRs.reduce((sum, pr) => sum + pr.deletions, 0);
+        // Repos
+        const repoCommits = user.repositories.nodes
+            .map((r) => ({
+            name: r.nameWithOwner,
+            commits: r.defaultBranchRef?.target?.history?.totalCount ?? 0,
+        }))
+            .filter((r) => r.commits > 0);
+        const reposContributed = repoCommits.length;
+        const totalRepoCommits = repoCommits.reduce((s, r) => s + r.commits, 0);
+        const topRepoShare = totalRepoCommits > 0
+            ? Math.max(...repoCommits.map((r) => r.commits)) / totalRepoCommits
+            : 0;
+        // Max daily spike approximation
+        const maxDailyCount = Math.max(...heatmapData.map((d) => d.count), 0);
+        const maxCommitsIn10Min = maxDailyCount >= 30 ? maxDailyCount : 0;
+        return {
+            handle: user.login,
+            displayName: user.name ?? undefined,
+            avatarUrl: user.avatarUrl,
+            commitsTotal: cc.contributionCalendar.totalContributions,
+            activeDays,
+            prsMergedCount,
+            prsMergedWeight,
+            reviewsSubmittedCount: cc.pullRequestReviewContributions.totalCount,
+            issuesClosedCount: cc.issueContributions.totalCount,
+            linesAdded,
+            linesDeleted,
+            reposContributed,
+            topRepoShare,
+            maxCommitsIn10Min,
+            heatmapData,
+            fetchedAt: new Date().toISOString(),
+        };
+    }
+    catch (err) {
+        console.error(`[cli] fetch error:`, err);
+        return null;
+    }
+}

package/dist/fetch-emu.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fetch-emu.test.js

@@ -0,0 +1,164 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { fetchEmuStats } from "./fetch-emu";
+// Mock global fetch
+const mockFetch = vi.fn();
+describe("fetchEmuStats", () => {
+    beforeEach(() => {
+        vi.stubGlobal("fetch", mockFetch);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("returns Stats90d on successful GraphQL response", async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                data: {
+                    user: {
+                        login: "Juan_corp",
+                        name: "Juan Corp",
+                        avatarUrl: "https://example.com/avatar.png",
+                        contributionsCollection: {
+                            contributionCalendar: {
+                                totalContributions: 42,
+                                weeks: [
+                                    {
+                                        contributionDays: [
+                                            { date: "2025-01-01", contributionCount: 5 },
+                                            { date: "2025-01-02", contributionCount: 0 },
+                                        ],
+                                    },
+                                ],
+                            },
+                            pullRequestContributions: {
+                                totalCount: 3,
+                                nodes: [
+                                    {
+                                        pullRequest: {
+                                            additions: 100,
+                                            deletions: 50,
+                                            changedFiles: 3,
+                                            merged: true,
+                                        },
+                                    },
+                                    {
+                                        pullRequest: {
+                                            additions: 20,
+                                            deletions: 5,
+                                            changedFiles: 1,
+                                            merged: false,
+                                        },
+                                    },
+                                ],
+                            },
+                            pullRequestReviewContributions: { totalCount: 5 },
+                            issueContributions: { totalCount: 2 },
+                        },
+                        repositories: {
+                            totalCount: 3,
+                            nodes: [
+                                {
+                                    nameWithOwner: "org/repo1",
+                                    defaultBranchRef: {
+                                        target: { history: { totalCount: 30 } },
+                                    },
+                                },
+                                {
+                                    nameWithOwner: "org/repo2",
+                                    defaultBranchRef: {
+                                        target: { history: { totalCount: 10 } },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            }),
+        });
+        const result = await fetchEmuStats("Juan_corp", "ghp_emu_token");
+        expect(result).not.toBeNull();
+        expect(result.handle).toBe("Juan_corp");
+        expect(result.commitsTotal).toBe(42);
+        expect(result.prsMergedCount).toBe(1); // only merged
+        expect(result.reviewsSubmittedCount).toBe(5);
+        expect(result.issuesClosedCount).toBe(2);
+        expect(result.reposContributed).toBe(2);
+        expect(result.heatmapData).toHaveLength(2);
+        expect(result.activeDays).toBe(1); // only Jan 1 has count > 0
+    });
+    it("sends Authorization header with EMU token", async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ data: { user: null } }),
+        });
+        await fetchEmuStats("corp_user", "ghp_test_token");
+        expect(mockFetch).toHaveBeenCalledWith("https://api.github.com/graphql", expect.objectContaining({
+            headers: expect.objectContaining({
+                Authorization: "Bearer ghp_test_token",
+            }),
+        }));
+    });
+    it("returns null when API returns HTTP error", async () => {
+        mockFetch.mockResolvedValue({
+            ok: false,
+            status: 401,
+            text: async () => "Unauthorized",
+        });
+        const result = await fetchEmuStats("corp_user", "bad_token");
+        expect(result).toBeNull();
+    });
+    it("returns null when user is not found", async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ data: { user: null } }),
+        });
+        const result = await fetchEmuStats("nonexistent_user", "ghp_token");
+        expect(result).toBeNull();
+    });
+    it("returns null when fetch throws", async () => {
+        mockFetch.mockRejectedValue(new Error("Network error"));
+        const result = await fetchEmuStats("corp_user", "ghp_token");
+        expect(result).toBeNull();
+    });
+    it("filters out null PR nodes", async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                data: {
+                    user: {
+                        login: "corp_user",
+                        name: null,
+                        avatarUrl: "https://example.com/avatar.png",
+                        contributionsCollection: {
+                            contributionCalendar: {
+                                totalContributions: 10,
+                                weeks: [],
+                            },
+                            pullRequestContributions: {
+                                totalCount: 2,
+                                nodes: [
+                                    null,
+                                    { pullRequest: null },
+                                    {
+                                        pullRequest: {
+                                            additions: 10,
+                                            deletions: 5,
+                                            changedFiles: 1,
+                                            merged: true,
+                                        },
+                                    },
+                                ],
+                            },
+                            pullRequestReviewContributions: { totalCount: 0 },
+                            issueContributions: { totalCount: 0 },
+                        },
+                        repositories: { totalCount: 0, nodes: [] },
+                    },
+                },
+            }),
+        });
+        const result = await fetchEmuStats("corp_user", "ghp_token");
+        expect(result).not.toBeNull();
+        expect(result.prsMergedCount).toBe(1);
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { parseArgs } from "./cli.js";
+import { resolveToken } from "./auth.js";
+import { fetchEmuStats } from "./fetch-emu.js";
+import { uploadSupplementalStats } from "./upload.js";
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.command !== "merge") {
+        console.error("Usage: chapa merge --handle <personal> --emu-handle <emu> [--emu-token <token>] [--token <token>] [--server <url>]");
+        process.exit(1);
+    }
+    if (!args.handle || !args.emuHandle) {
+        console.error("Error: --handle and --emu-handle are required.");
+        process.exit(1);
+    }
+    // Resolve tokens
+    const emuToken = resolveToken(args.emuToken, "GITHUB_EMU_TOKEN");
+    if (!emuToken) {
+        console.error("Error: EMU token required. Use --emu-token, set GITHUB_EMU_TOKEN, or ensure `gh auth token` works.");
+        process.exit(1);
+    }
+    const personalToken = resolveToken(args.token, "GITHUB_TOKEN");
+    if (!personalToken) {
+        console.error("Error: Personal token required. Use --token, set GITHUB_TOKEN, or ensure `gh auth token` works.");
+        process.exit(1);
+    }
+    // Fetch EMU stats
+    console.log(`Fetching stats for EMU account: ${args.emuHandle}...`);
+    const emuStats = await fetchEmuStats(args.emuHandle, emuToken);
+    if (!emuStats) {
+        console.error("Error: Failed to fetch EMU stats. Check your EMU token and handle.");
+        process.exit(1);
+    }
+    console.log(`Found: ${emuStats.commitsTotal} commits, ${emuStats.prsMergedCount} PRs merged, ${emuStats.reviewsSubmittedCount} reviews`);
+    // Upload to Chapa
+    console.log(`Uploading supplemental stats to ${args.server}...`);
+    const result = await uploadSupplementalStats({
+        targetHandle: args.handle,
+        sourceHandle: args.emuHandle,
+        stats: emuStats,
+        token: personalToken,
+        serverUrl: args.server,
+    });
+    if (!result.success) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+    }
+    console.log("Success! Supplemental stats uploaded. Your badge will reflect combined data on next refresh.");
+}
+main();

package/dist/upload.d.ts

@@ -0,0 +1,14 @@
+import type { Stats90d } from "@chapa/shared";
+interface UploadOptions {
+    targetHandle: string;
+    sourceHandle: string;
+    stats: Stats90d;
+    token: string;
+    serverUrl: string;
+}
+interface UploadResult {
+    success: boolean;
+    error?: string;
+}
+export declare function uploadSupplementalStats(opts: UploadOptions): Promise<UploadResult>;
+export {};

package/dist/upload.js

@@ -0,0 +1,32 @@
+export async function uploadSupplementalStats(opts) {
+    const baseUrl = opts.serverUrl.replace(/\/+$/, "");
+    const url = `${baseUrl}/api/supplemental`;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${opts.token}`,
+            },
+            body: JSON.stringify({
+                targetHandle: opts.targetHandle,
+                sourceHandle: opts.sourceHandle,
+                stats: opts.stats,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            return {
+                success: false,
+                error: `Server returned ${res.status}: ${body.error ?? "Unknown error"}`,
+            };
+        }
+        return { success: true };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Upload failed: ${err.message}`,
+        };
+    }
+}

package/dist/upload.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/upload.test.js

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { uploadSupplementalStats } from "./upload";
+const mockFetch = vi.fn();
+function makeStats() {
+    return {
+        handle: "corp_user",
+        commitsTotal: 30,
+        activeDays: 10,
+        prsMergedCount: 3,
+        prsMergedWeight: 5,
+        reviewsSubmittedCount: 2,
+        issuesClosedCount: 1,
+        linesAdded: 500,
+        linesDeleted: 200,
+        reposContributed: 2,
+        topRepoShare: 0.6,
+        maxCommitsIn10Min: 3,
+        heatmapData: [],
+        fetchedAt: new Date().toISOString(),
+    };
+}
+describe("uploadSupplementalStats", () => {
+    beforeEach(() => {
+        vi.stubGlobal("fetch", mockFetch);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("sends POST with correct body and auth header", async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: async () => ({ success: true }),
+        });
+        const result = await uploadSupplementalStats({
+            targetHandle: "juan294",
+            sourceHandle: "corp_user",
+            stats: makeStats(),
+            token: "gho_personal",
+            serverUrl: "https://chapa.thecreativetoken.com",
+        });
+        expect(result.success).toBe(true);
+        expect(mockFetch).toHaveBeenCalledWith("https://chapa.thecreativetoken.com/api/supplemental", expect.objectContaining({
+            method: "POST",
+            headers: expect.objectContaining({
+                Authorization: "Bearer gho_personal",
+                "Content-Type": "application/json",
+            }),
+        }));
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.targetHandle).toBe("juan294");
+        expect(body.sourceHandle).toBe("corp_user");
+        expect(body.stats).toEqual(expect.objectContaining({ handle: "corp_user", commitsTotal: 30 }));
+    });
+    it("returns error message on 401", async () => {
+        mockFetch.mockResolvedValue({
+            ok: false,
+            status: 401,
+            json: async () => ({ error: "Invalid token" }),
+        });
+        const result = await uploadSupplementalStats({
+            targetHandle: "juan294",
+            sourceHandle: "corp_user",
+            stats: makeStats(),
+            token: "bad_token",
+            serverUrl: "https://chapa.thecreativetoken.com",
+        });
+        expect(result.success).toBe(false);
+        expect(result.error).toContain("401");
+    });
+    it("returns error message on 403", async () => {
+        mockFetch.mockResolvedValue({
+            ok: false,
+            status: 403,
+            json: async () => ({ error: "Handle mismatch" }),
+        });
+        const result = await uploadSupplementalStats({
+            targetHandle: "juan294",
+            sourceHandle: "corp_user",
+            stats: makeStats(),
+            token: "wrong_user_token",
+            serverUrl: "https://chapa.thecreativetoken.com",
+        });
+        expect(result.success).toBe(false);
+        expect(result.error).toContain("403");
+    });
+    it("returns error on network failure", async () => {
+        mockFetch.mockRejectedValue(new Error("Connection refused"));
+        const result = await uploadSupplementalStats({
+            targetHandle: "juan294",
+            sourceHandle: "corp_user",
+            stats: makeStats(),
+            token: "gho_personal",
+            serverUrl: "https://chapa.thecreativetoken.com",
+        });
+        expect(result.success).toBe(false);
+        expect(result.error).toContain("Connection refused");
+    });
+    it("strips trailing slash from server URL", async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: async () => ({ success: true }),
+        });
+        await uploadSupplementalStats({
+            targetHandle: "juan294",
+            sourceHandle: "corp_user",
+            stats: makeStats(),
+            token: "gho_personal",
+            serverUrl: "https://chapa.thecreativetoken.com/",
+        });
+        expect(mockFetch).toHaveBeenCalledWith("https://chapa.thecreativetoken.com/api/supplemental", expect.anything());
+    });
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "chapa-cli",
+  "version": "0.1.0",
+  "description": "Merge GitHub EMU contributions into your Chapa developer impact badge",
+  "type": "module",
+  "bin": {
+    "chapa": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "chapa",
+    "github",
+    "badge",
+    "developer",
+    "impact",
+    "emu",
+    "cli"
+  ],
+  "author": "juan294",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/juan294/chapa",
+    "directory": "packages/cli"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@chapa/shared": "workspace:*",
+    "@types/node": "^22.19.10",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.3"
+  }
+}