@0xbigboss/gh-pulse-core 1.0.0

package/dist/reports/utils.js

@@ -0,0 +1,65 @@
+import { diffInDays } from "../time.js";
+export function buildPullRequestSummary(pr, now) {
+    return {
+        repo: pr.repo,
+        number: pr.number,
+        title: pr.title,
+        author: pr.author,
+        state: pr.state,
+        draft: pr.draft,
+        updated_at: pr.updated_at,
+        created_at: pr.created_at,
+        age_days: diffInDays(pr.created_at, now),
+    };
+}
+export function computeCycleTime(pr, events) {
+    if (pr.merged_at === null) {
+        return null;
+    }
+    const openedAt = minTimestamp(events.filter((event) => event.type === 'pr_opened').map((e) => e.opened_at));
+    const readyAt = minTimestamp(events.filter((event) => event.type === 'pr_ready').map((e) => e.ready_at));
+    const firstReviewAt = minTimestamp(events.filter((event) => event.type === 'review_submitted').map((event) => event.submitted_at));
+    const openTime = openedAt ?? pr.created_at;
+    const readyTime = readyAt ?? openTime;
+    const reviewStart = firstReviewAt ?? null;
+    const draftTime = readyAt ? readyTime - openTime : null;
+    const reviewTime = reviewStart ? reviewStart - readyTime : 0;
+    const mergeTime = reviewStart ? pr.merged_at - reviewStart : 0;
+    const totalTime = pr.merged_at - openTime;
+    return {
+        draft_time: draftTime,
+        review_time: reviewTime,
+        merge_time: mergeTime,
+        total_time: totalTime,
+    };
+}
+export function computeReviewEngagement(pr, events) {
+    const comments = events.filter((event) => event.type === 'comment_added');
+    const reviews = events.filter((event) => event.type === 'review_submitted');
+    if (comments.length === 0 && reviews.length === 0) {
+        return null;
+    }
+    const firstComment = minTimestamp(comments.map((event) => event.commented_at));
+    const firstReview = minTimestamp(reviews.map((event) => event.submitted_at));
+    return {
+        time_to_first_comment: firstComment ? firstComment - pr.created_at : null,
+        time_to_first_review: firstReview ? firstReview - pr.created_at : null,
+        review_count: reviews.length,
+        comment_count: comments.length,
+    };
+}
+export function percentile(values, pct) {
+    if (values.length === 0) {
+        return null;
+    }
+    const sorted = [...values].toSorted((a, b) => a - b);
+    const index = Math.floor((pct / 100) * (sorted.length - 1));
+    return sorted[index] ?? null;
+}
+function minTimestamp(values) {
+    const filtered = values.filter((value) => typeof value === 'number');
+    if (filtered.length === 0) {
+        return null;
+    }
+    return Math.min(...filtered);
+}

package/dist/repos.cjs

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRepos = resolveRepos;
+const picomatch_1 = __importDefault(require("picomatch"));
+async function resolveRepos(options) {
+    const orgs = uniqueStrings([...(options.config.orgs ?? []), ...(options.orgs ?? [])]);
+    const repoPatterns = options.repoPatterns ?? [];
+    const repoSet = new Set();
+    // orgs can include GitHub orgs OR usernames - we try org first, fall back to user
+    for (const [index, org] of orgs.entries()) {
+        options.onProgress?.({
+            phase: 'resolve',
+            message: `Resolving repos for ${org}`,
+            current: index + 1,
+            total: orgs.length,
+        });
+        const repos = await listOwnerRepos(options.github, org);
+        repos.forEach((repo) => repoSet.add(repo));
+    }
+    for (const pattern of options.config.repos ?? []) {
+        if (pattern.includes('*')) {
+            const owner = pattern.split('/')[0] ?? '';
+            if (!owner) {
+                throw new Error(`Invalid repo pattern: ${pattern}`);
+            }
+            options.onProgress?.({
+                phase: 'resolve',
+                message: `Resolving repos for ${owner}`,
+            });
+            const repos = await listOwnerRepos(options.github, owner);
+            const matcher = (0, picomatch_1.default)(pattern);
+            repos.filter((repo) => matcher(repo)).forEach((repo) => repoSet.add(repo));
+            continue;
+        }
+        repoSet.add(pattern);
+    }
+    let repos = [...repoSet];
+    const patterns = repoPatterns
+        .flatMap((pattern) => pattern.split(',').map((p) => p.trim()))
+        .filter(Boolean);
+    const needsFilter = patterns.length > 0 || options.config.exclude.forks || options.config.exclude.archived;
+    if (repos.length > 0 || needsFilter) {
+        options.onProgress?.({
+            phase: 'resolve',
+            message: `Found ${repos.length} repos${needsFilter ? ', filtering...' : ''}`,
+        });
+    }
+    if (patterns.length > 0) {
+        const matcher = (0, picomatch_1.default)(patterns);
+        repos = repos.filter((repo) => matcher(repo));
+    }
+    if (options.config.exclude.forks || options.config.exclude.archived) {
+        repos = await filterRepoStates(repos, options);
+    }
+    else if (options.strict ?? true) {
+        await verifyReposAccessible(repos, options);
+    }
+    return repos.toSorted();
+}
+async function listOwnerRepos(github, owner) {
+    try {
+        return await github.listOrgRepos(owner);
+    }
+    catch (error) {
+        const status = getStatus(error);
+        if (status === 404) {
+            return github.listUserRepos(owner);
+        }
+        throw error;
+    }
+}
+async function filterRepoStates(repos, options) {
+    const results = [];
+    for (const repo of repos) {
+        const detail = await options.github.getRepo(repo);
+        if (options.config.exclude.forks && detail.fork) {
+            continue;
+        }
+        if (options.config.exclude.archived && detail.archived) {
+            continue;
+        }
+        results.push(detail.full_name);
+    }
+    return results;
+}
+async function verifyReposAccessible(repos, options) {
+    for (const repo of repos) {
+        await options.github.ensureRepoAccessible(repo);
+    }
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function getStatus(error) {
+    if (typeof error === 'object' && error && 'status' in error) {
+        return error.status;
+    }
+    return undefined;
+}

package/dist/repos.d.cts

@@ -0,0 +1,12 @@
+import type { Config } from "./config.cjs";
+import type { GitHubClient } from "./github.cjs";
+import type { ProgressEvent, RepoFullName } from "./types.cjs";
+export interface ResolveReposOptions {
+    config: Config;
+    github: GitHubClient;
+    orgs?: string[];
+    repoPatterns?: string[];
+    strict?: boolean;
+    onProgress?: (event: ProgressEvent) => void;
+}
+export declare function resolveRepos(options: ResolveReposOptions): Promise<RepoFullName[]>;

package/dist/repos.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from "./config.js";
+import type { GitHubClient } from "./github.js";
+import type { ProgressEvent, RepoFullName } from "./types.js";
+export interface ResolveReposOptions {
+    config: Config;
+    github: GitHubClient;
+    orgs?: string[];
+    repoPatterns?: string[];
+    strict?: boolean;
+    onProgress?: (event: ProgressEvent) => void;
+}
+export declare function resolveRepos(options: ResolveReposOptions): Promise<RepoFullName[]>;

package/dist/repos.js

@@ -0,0 +1,96 @@
+import picomatch from 'picomatch';
+export async function resolveRepos(options) {
+    const orgs = uniqueStrings([...(options.config.orgs ?? []), ...(options.orgs ?? [])]);
+    const repoPatterns = options.repoPatterns ?? [];
+    const repoSet = new Set();
+    // orgs can include GitHub orgs OR usernames - we try org first, fall back to user
+    for (const [index, org] of orgs.entries()) {
+        options.onProgress?.({
+            phase: 'resolve',
+            message: `Resolving repos for ${org}`,
+            current: index + 1,
+            total: orgs.length,
+        });
+        const repos = await listOwnerRepos(options.github, org);
+        repos.forEach((repo) => repoSet.add(repo));
+    }
+    for (const pattern of options.config.repos ?? []) {
+        if (pattern.includes('*')) {
+            const owner = pattern.split('/')[0] ?? '';
+            if (!owner) {
+                throw new Error(`Invalid repo pattern: ${pattern}`);
+            }
+            options.onProgress?.({
+                phase: 'resolve',
+                message: `Resolving repos for ${owner}`,
+            });
+            const repos = await listOwnerRepos(options.github, owner);
+            const matcher = picomatch(pattern);
+            repos.filter((repo) => matcher(repo)).forEach((repo) => repoSet.add(repo));
+            continue;
+        }
+        repoSet.add(pattern);
+    }
+    let repos = [...repoSet];
+    const patterns = repoPatterns
+        .flatMap((pattern) => pattern.split(',').map((p) => p.trim()))
+        .filter(Boolean);
+    const needsFilter = patterns.length > 0 || options.config.exclude.forks || options.config.exclude.archived;
+    if (repos.length > 0 || needsFilter) {
+        options.onProgress?.({
+            phase: 'resolve',
+            message: `Found ${repos.length} repos${needsFilter ? ', filtering...' : ''}`,
+        });
+    }
+    if (patterns.length > 0) {
+        const matcher = picomatch(patterns);
+        repos = repos.filter((repo) => matcher(repo));
+    }
+    if (options.config.exclude.forks || options.config.exclude.archived) {
+        repos = await filterRepoStates(repos, options);
+    }
+    else if (options.strict ?? true) {
+        await verifyReposAccessible(repos, options);
+    }
+    return repos.toSorted();
+}
+async function listOwnerRepos(github, owner) {
+    try {
+        return await github.listOrgRepos(owner);
+    }
+    catch (error) {
+        const status = getStatus(error);
+        if (status === 404) {
+            return github.listUserRepos(owner);
+        }
+        throw error;
+    }
+}
+async function filterRepoStates(repos, options) {
+    const results = [];
+    for (const repo of repos) {
+        const detail = await options.github.getRepo(repo);
+        if (options.config.exclude.forks && detail.fork) {
+            continue;
+        }
+        if (options.config.exclude.archived && detail.archived) {
+            continue;
+        }
+        results.push(detail.full_name);
+    }
+    return results;
+}
+async function verifyReposAccessible(repos, options) {
+    for (const repo of repos) {
+        await options.github.ensureRepoAccessible(repo);
+    }
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function getStatus(error) {
+    if (typeof error === 'object' && error && 'status' in error) {
+        return error.status;
+    }
+    return undefined;
+}

package/dist/sync.cjs

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncRepos = syncRepos;
+const cache_1 = require("./cache.cjs");
+async function syncRepos(options) {
+    const now = Date.now();
+    const syncTtlMs = options.config.cache.sync_ttl_hours * 60 * 60 * 1000;
+    const concurrency = options.config.cache.concurrency;
+    // Filter repos that need syncing
+    const reposToSync = [];
+    const skippedRepos = [];
+    for (const repo of options.repos) {
+        if (options.forceSync) {
+            reposToSync.push(repo);
+            continue;
+        }
+        const syncState = options.cache.getSyncState(repo);
+        if (syncState && now - syncState.last_sync < syncTtlMs) {
+            skippedRepos.push(repo);
+        }
+        else {
+            reposToSync.push(repo);
+        }
+    }
+    if (skippedRepos.length > 0) {
+        options.onProgress?.({
+            phase: 'sync',
+            message: `Skipping ${skippedRepos.length} repos (synced within ${options.config.cache.sync_ttl_hours}h)`,
+        });
+    }
+    if (reposToSync.length === 0) {
+        options.onProgress?.({
+            phase: 'sync',
+            message: 'All repos up to date',
+        });
+        return {
+            synced_at: now,
+            repos: options.repos,
+            events_inserted: 0,
+            pull_requests_upserted: 0,
+            commits_upserted: 0,
+        };
+    }
+    let eventsInserted = 0;
+    let prsUpserted = 0;
+    let commitsUpserted = 0;
+    let completed = 0;
+    // Process repos in parallel with concurrency limit
+    const processRepo = async (repo) => {
+        const repoResult = await syncRepo(repo, options);
+        eventsInserted += repoResult.eventsInserted;
+        prsUpserted += repoResult.prsUpserted;
+        commitsUpserted += repoResult.commitsUpserted;
+        options.cache.upsertSyncState(repo, now, null);
+        completed += 1;
+        options.onProgress?.({
+            phase: 'sync',
+            message: `Synced ${repo} (${repoResult.prsUpserted} PRs, ${repoResult.commitsUpserted} commits)`,
+            current: completed,
+            total: reposToSync.length,
+        });
+    };
+    // Run with concurrency limit
+    await runWithConcurrency(reposToSync, processRepo, concurrency);
+    return {
+        synced_at: now,
+        repos: options.repos,
+        events_inserted: eventsInserted,
+        pull_requests_upserted: prsUpserted,
+        commits_upserted: commitsUpserted,
+    };
+}
+async function runWithConcurrency(items, fn, concurrency) {
+    if (!Number.isFinite(concurrency) || concurrency <= 0) {
+        throw new Error(`Invalid concurrency: ${concurrency}`);
+    }
+    if (items.length === 0) {
+        return;
+    }
+    const queue = [...items];
+    const running = new Set();
+    let firstError = null;
+    while (queue.length > 0 || running.size > 0) {
+        while (!firstError && running.size < concurrency && queue.length > 0) {
+            const item = queue.shift();
+            if (item === undefined) {
+                break;
+            }
+            const promise = Promise.resolve().then(() => fn(item));
+            const tracked = promise.finally(() => {
+                running.delete(tracked);
+            });
+            running.add(tracked);
+        }
+        if (running.size > 0) {
+            try {
+                await Promise.race(running);
+            }
+            catch (error) {
+                if (!firstError) {
+                    firstError = error;
+                    queue.length = 0;
+                }
+            }
+        }
+    }
+    if (firstError) {
+        throw firstError;
+    }
+}
+async function syncRepo(repo, options) {
+    const { cache, github, config, timeRange } = options;
+    const now = Date.now();
+    let eventsInserted = 0;
+    let prsUpserted = 0;
+    let commitsUpserted = 0;
+    const pullRequests = await github.listPullRequests(repo);
+    for (const prListItem of pullRequests) {
+        const updatedAt = Date.parse(prListItem.updated_at);
+        if (prListItem.state !== 'open' && updatedAt < timeRange.start) {
+            continue;
+        }
+        const existing = cache.getPullRequest(repo, prListItem.number);
+        const shouldFetch = !existing || !cache.isFresh(existing.fetched_at, config.cache.ttl_hours);
+        if (shouldFetch) {
+            const prDetail = await github.getPullRequest(repo, prListItem.number);
+            const pr = toPullRequest(repo, prDetail);
+            cache.upsertPullRequest(pr, now);
+            prsUpserted += 1;
+            eventsInserted += insertPrEvents(cache, pr, prDetail.merged_by?.login ?? pr.author);
+            eventsInserted += await insertTimelineEvents(cache, github, pr);
+            eventsInserted += await insertReviewEvents(cache, github, pr);
+            eventsInserted += await insertCommentEvents(cache, github, pr);
+        }
+        else if (existing) {
+            eventsInserted += insertPrEvents(cache, existing.data);
+        }
+    }
+    const commitList = await github.listCommits(repo, {
+        since: new Date(timeRange.start).toISOString(),
+        until: new Date(timeRange.end).toISOString(),
+    });
+    for (const commitItem of commitList) {
+        const sha = commitItem.sha;
+        const existingCommit = cache.getCommit(repo, sha);
+        const shouldFetch = !existingCommit || !cache.isFresh(existingCommit.fetched_at, config.cache.ttl_hours);
+        let commitDetail = null;
+        if (shouldFetch) {
+            commitDetail = await github.getCommit(repo, sha);
+        }
+        if (!commitDetail && existingCommit) {
+            const commitEvent = toCommitEventFromCommit(repo, existingCommit.data);
+            const inserted = cache.insertEvent(commitEvent, now);
+            if (inserted) {
+                eventsInserted += 1;
+            }
+            continue;
+        }
+        const commitEvent = toCommitEvent(repo, commitDetail);
+        const inserted = cache.insertEvent(commitEvent, now);
+        if (inserted) {
+            eventsInserted += 1;
+        }
+        cache.upsertCommit((0, cache_1.toCommitFromEvent)(commitEvent), now);
+        commitsUpserted += 1;
+    }
+    return { eventsInserted, prsUpserted, commitsUpserted };
+}
+function insertPrEvents(cache, pr, mergedBy) {
+    let count = 0;
+    const openedEvent = {
+        type: 'pr_opened',
+        repo: pr.repo,
+        pr_number: pr.number,
+        author: pr.author,
+        opened_at: pr.created_at,
+        is_draft: pr.draft,
+    };
+    if (cache.insertEvent(openedEvent)) {
+        count += 1;
+    }
+    if (pr.merged_at) {
+        const mergedEvent = {
+            type: 'pr_merged',
+            repo: pr.repo,
+            pr_number: pr.number,
+            merged_at: pr.merged_at,
+            merged_by: mergedBy ?? pr.author,
+        };
+        if (cache.insertEvent(mergedEvent)) {
+            count += 1;
+        }
+    }
+    else if (pr.closed_at) {
+        const closedEvent = {
+            type: 'pr_closed',
+            repo: pr.repo,
+            pr_number: pr.number,
+            closed_at: pr.closed_at,
+        };
+        if (cache.insertEvent(closedEvent)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+async function insertTimelineEvents(cache, github, pr) {
+    let count = 0;
+    const events = await github.listIssueEvents(pr.repo, pr.number);
+    for (const event of events) {
+        if (event.event === 'ready_for_review') {
+            const readyEvent = {
+                type: 'pr_ready',
+                repo: pr.repo,
+                pr_number: pr.number,
+                ready_at: Date.parse(event.created_at),
+            };
+            if (cache.insertEvent(readyEvent)) {
+                count += 1;
+            }
+        }
+        if (event.event === 'reopened') {
+            const reopenedEvent = {
+                type: 'pr_opened',
+                repo: pr.repo,
+                pr_number: pr.number,
+                author: pr.author,
+                opened_at: Date.parse(event.created_at),
+                is_draft: false,
+            };
+            if (cache.insertEvent(reopenedEvent)) {
+                count += 1;
+            }
+        }
+        if (event.event === 'closed' && pr.merged_at === null) {
+            const closedEvent = {
+                type: 'pr_closed',
+                repo: pr.repo,
+                pr_number: pr.number,
+                closed_at: Date.parse(event.created_at),
+            };
+            if (cache.insertEvent(closedEvent)) {
+                count += 1;
+            }
+        }
+    }
+    return count;
+}
+async function insertReviewEvents(cache, github, pr) {
+    let count = 0;
+    const reviews = await github.listPullRequestReviews(pr.repo, pr.number);
+    for (const review of reviews) {
+        const reviewer = review.user?.login;
+        if (!reviewer || !review.submitted_at) {
+            continue;
+        }
+        const reviewEvent = {
+            type: 'review_submitted',
+            repo: pr.repo,
+            pr_number: pr.number,
+            reviewer,
+            state: normalizeReviewState(review.state),
+            submitted_at: Date.parse(review.submitted_at),
+        };
+        if (cache.insertEvent(reviewEvent)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+async function insertCommentEvents(cache, github, pr) {
+    let count = 0;
+    const comments = await github.listIssueComments(pr.repo, pr.number);
+    for (const comment of comments) {
+        const author = comment.user?.login;
+        if (!author) {
+            continue;
+        }
+        const commentEvent = {
+            type: 'comment_added',
+            repo: pr.repo,
+            pr_number: pr.number,
+            author,
+            commented_at: Date.parse(comment.created_at),
+        };
+        if (cache.insertEvent(commentEvent)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function toPullRequest(repo, pr) {
+    return {
+        repo,
+        number: pr.number,
+        title: pr.title,
+        state: pr.merged_at ? 'merged' : pr.state,
+        draft: pr.draft ?? false,
+        author: pr.user?.login ?? 'unknown',
+        created_at: Date.parse(pr.created_at),
+        updated_at: Date.parse(pr.updated_at),
+        merged_at: pr.merged_at ? Date.parse(pr.merged_at) : null,
+        closed_at: pr.closed_at ? Date.parse(pr.closed_at) : null,
+        additions: pr.additions ?? 0,
+        deletions: pr.deletions ?? 0,
+        commits: pr.commits ?? 0,
+        requested_reviewers: (pr.requested_reviewers ?? []).map((reviewer) => reviewer.login ?? 'unknown'),
+        labels: (pr.labels ?? []).map((label) => typeof label === 'string' ? label : (label.name ?? 'unknown')),
+        linked_issues: [],
+    };
+}
+function toCommitEvent(repo, commit) {
+    const author = commit.author?.login ?? commit.commit.author?.name ?? 'unknown';
+    const message = commit.commit.message ?? '';
+    const stats = commit.stats ?? { additions: 0, deletions: 0, total: 0 };
+    const filesChanged = commit.files ? commit.files.length : 0;
+    const committedAt = commit.commit.author?.date
+        ? Date.parse(commit.commit.author.date)
+        : Date.now();
+    return {
+        type: 'commit_pushed',
+        repo,
+        sha: commit.sha,
+        author,
+        committed_at: committedAt,
+        message,
+        additions: stats.additions ?? 0,
+        deletions: stats.deletions ?? 0,
+        files_changed: filesChanged,
+    };
+}
+function toCommitEventFromCommit(repo, commit) {
+    return {
+        type: 'commit_pushed',
+        repo,
+        sha: commit.sha,
+        author: commit.author,
+        committed_at: commit.committed_at,
+        message: commit.message,
+        additions: commit.additions,
+        deletions: commit.deletions,
+        files_changed: commit.files_changed,
+    };
+}
+function normalizeReviewState(state) {
+    switch (state) {
+        case 'approved':
+            return 'approved';
+        case 'changes_requested':
+            return 'changes_requested';
+        case 'commented':
+            return 'commented';
+        case 'dismissed':
+            return 'dismissed';
+        case 'pending':
+            return 'pending';
+        default:
+            return 'commented';
+    }
+}

package/dist/sync.d.cts

@@ -0,0 +1,24 @@
+import type { Cache } from "./cache.cjs";
+import type { Config } from "./config.cjs";
+import type { GitHubClient } from "./github.cjs";
+import type { ProgressEvent, RepoFullName, Timestamp } from "./types.cjs";
+export interface SyncOptions {
+    repos: RepoFullName[];
+    cache: Cache;
+    github: GitHubClient;
+    config: Config;
+    timeRange: {
+        start: Timestamp;
+        end: Timestamp;
+    };
+    forceSync?: boolean;
+    onProgress?: (event: ProgressEvent) => void;
+}
+export interface SyncResult {
+    synced_at: Timestamp;
+    repos: RepoFullName[];
+    events_inserted: number;
+    pull_requests_upserted: number;
+    commits_upserted: number;
+}
+export declare function syncRepos(options: SyncOptions): Promise<SyncResult>;

package/dist/sync.d.ts

@@ -0,0 +1,24 @@
+import type { Cache } from "./cache.js";
+import type { Config } from "./config.js";
+import type { GitHubClient } from "./github.js";
+import type { ProgressEvent, RepoFullName, Timestamp } from "./types.js";
+export interface SyncOptions {
+    repos: RepoFullName[];
+    cache: Cache;
+    github: GitHubClient;
+    config: Config;
+    timeRange: {
+        start: Timestamp;
+        end: Timestamp;
+    };
+    forceSync?: boolean;
+    onProgress?: (event: ProgressEvent) => void;
+}
+export interface SyncResult {
+    synced_at: Timestamp;
+    repos: RepoFullName[];
+    events_inserted: number;
+    pull_requests_upserted: number;
+    commits_upserted: number;
+}
+export declare function syncRepos(options: SyncOptions): Promise<SyncResult>;