@0xbigboss/gh-pulse-core 1.0.0

package/dist/sync.js

@@ -0,0 +1,357 @@
+import { toCommitFromEvent } from "./cache.js";
+export 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(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/team.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTeamMembers = resolveTeamMembers;
+async function resolveTeamMembers(options) {
+    const strategy = options.config.team.strategy;
+    switch (strategy) {
+        case 'config_list':
+            return unique(options.config.team.members);
+        case 'org_members': {
+            const orgs = unique([...options.config.orgs, ...(options.orgs ?? [])]);
+            const members = await Promise.all(orgs.map((org) => listOwnerMembers(options.github, org)));
+            return unique(members.flat());
+        }
+        case 'repo_contributors': {
+            const contributors = await Promise.all(options.repos.map((repo) => options.github.listContributors(repo)));
+            return unique(contributors.flat());
+        }
+        default: {
+            const _exhaustive = strategy;
+            throw new Error(`Unhandled team strategy: ${_exhaustive}`);
+        }
+    }
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+async function listOwnerMembers(github, owner) {
+    try {
+        return await github.listOrgMembers(owner);
+    }
+    catch (error) {
+        const status = getStatus(error);
+        if (status === 404) {
+            // Owner is a user, not an org - return the user as sole "member"
+            return [owner];
+        }
+        throw error;
+    }
+}
+function getStatus(error) {
+    if (typeof error === 'object' && error && 'status' in error) {
+        return error.status;
+    }
+    return undefined;
+}

package/dist/team.d.cts

@@ -0,0 +1,10 @@
+import type { Config } from "./config.cjs";
+import type { GitHubClient } from "./github.cjs";
+import type { GitHubUsername, RepoFullName } from "./types.cjs";
+export interface ResolveTeamOptions {
+    config: Config;
+    github: GitHubClient;
+    repos: RepoFullName[];
+    orgs?: string[];
+}
+export declare function resolveTeamMembers(options: ResolveTeamOptions): Promise<GitHubUsername[]>;

package/dist/team.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from "./config.js";
+import type { GitHubClient } from "./github.js";
+import type { GitHubUsername, RepoFullName } from "./types.js";
+export interface ResolveTeamOptions {
+    config: Config;
+    github: GitHubClient;
+    repos: RepoFullName[];
+    orgs?: string[];
+}
+export declare function resolveTeamMembers(options: ResolveTeamOptions): Promise<GitHubUsername[]>;

package/dist/team.js

@@ -0,0 +1,42 @@
+export async function resolveTeamMembers(options) {
+    const strategy = options.config.team.strategy;
+    switch (strategy) {
+        case 'config_list':
+            return unique(options.config.team.members);
+        case 'org_members': {
+            const orgs = unique([...options.config.orgs, ...(options.orgs ?? [])]);
+            const members = await Promise.all(orgs.map((org) => listOwnerMembers(options.github, org)));
+            return unique(members.flat());
+        }
+        case 'repo_contributors': {
+            const contributors = await Promise.all(options.repos.map((repo) => options.github.listContributors(repo)));
+            return unique(contributors.flat());
+        }
+        default: {
+            const _exhaustive = strategy;
+            throw new Error(`Unhandled team strategy: ${_exhaustive}`);
+        }
+    }
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+async function listOwnerMembers(github, owner) {
+    try {
+        return await github.listOrgMembers(owner);
+    }
+    catch (error) {
+        const status = getStatus(error);
+        if (status === 404) {
+            // Owner is a user, not an org - return the user as sole "member"
+            return [owner];
+        }
+        throw error;
+    }
+}
+function getStatus(error) {
+    if (typeof error === 'object' && error && 'status' in error) {
+        return error.status;
+    }
+    return undefined;
+}

package/dist/time.cjs

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.periodToRange = periodToRange;
+exports.resolveSince = resolveSince;
+exports.resolveUntil = resolveUntil;
+exports.formatTimestamp = formatTimestamp;
+exports.diffInDays = diffInDays;
+exports.parseRelativeDuration = parseRelativeDuration;
+const DAY_MS = 24 * 60 * 60 * 1000;
+function periodToRange(period, now, timeZone) {
+    const end = now.getTime();
+    switch (period) {
+        case 'today': {
+            const start = startOfDay(now, timeZone);
+            return { start, end, label: 'today' };
+        }
+        case 'week': {
+            const start = end - 7 * DAY_MS;
+            return { start, end, label: 'last 7 days' };
+        }
+        case 'sprint': {
+            const start = end - 14 * DAY_MS;
+            return { start, end, label: 'last 14 days' };
+        }
+        case 'month': {
+            const start = end - 30 * DAY_MS;
+            return { start, end, label: 'last 30 days' };
+        }
+        case 'quarter': {
+            const start = end - 90 * DAY_MS;
+            return { start, end, label: 'last 90 days' };
+        }
+        default: {
+            const _exhaustive = period;
+            throw new Error(`Unhandled period: ${_exhaustive}`);
+        }
+    }
+}
+function resolveSince(input, now) {
+    if (isRelative(input)) {
+        return now.getTime() - parseRelativeDuration(input);
+    }
+    return parseAbsoluteDate(input);
+}
+function resolveUntil(input, now) {
+    if (isRelative(input)) {
+        return now.getTime() - parseRelativeDuration(input);
+    }
+    return parseAbsoluteDate(input);
+}
+function formatTimestamp(timestamp, timeZone) {
+    const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+    });
+    return formatter.format(new Date(timestamp));
+}
+function diffInDays(start, end) {
+    return Math.floor((end - start) / DAY_MS);
+}
+function parseRelativeDuration(input) {
+    const match = input.trim().match(/^(\d+)([dwmy])$/i);
+    if (!match) {
+        throw new Error(`Invalid relative duration: ${input}`);
+    }
+    const value = Number(match[1]);
+    const unitRaw = match[2];
+    if (!unitRaw) {
+        throw new Error(`Invalid relative duration unit: ${input}`);
+    }
+    const unit = unitRaw.toLowerCase();
+    switch (unit) {
+        case 'd':
+            return value * DAY_MS;
+        case 'w':
+            return value * 7 * DAY_MS;
+        case 'm':
+            return value * 30 * DAY_MS;
+        case 'y':
+            return value * 365 * DAY_MS;
+        default: {
+            const _exhaustive = unit;
+            throw new Error(`Unhandled duration unit: ${_exhaustive}`);
+        }
+    }
+}
+function isRelative(input) {
+    return /^(\d+)([dwmy])$/i.test(input.trim());
+}
+function parseAbsoluteDate(input) {
+    const parsed = Date.parse(input);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Invalid date: ${input}`);
+    }
+    return parsed;
+}
+function startOfDay(now, timeZone) {
+    const parts = getZonedParts(now, timeZone);
+    const utcMs = zonedTimeToUtcMs({
+        ...parts,
+        hour: 0,
+        minute: 0,
+        second: 0,
+    }, timeZone);
+    return utcMs;
+}
+function getZonedParts(date, timeZone) {
+    const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        hour12: false,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    });
+    const parts = formatter.formatToParts(date);
+    const lookup = Object.fromEntries(parts.filter((part) => part.type !== 'literal').map((part) => [part.type, part.value]));
+    const year = lookup.year;
+    const month = lookup.month;
+    const day = lookup.day;
+    const hour = lookup.hour;
+    const minute = lookup.minute;
+    const second = lookup.second;
+    if (!year || !month || !day || !hour || !minute || !second) {
+        throw new Error(`Failed to resolve timezone parts for ${timeZone}`);
+    }
+    return {
+        year: Number(year),
+        month: Number(month),
+        day: Number(day),
+        hour: Number(hour),
+        minute: Number(minute),
+        second: Number(second),
+    };
+}
+function zonedTimeToUtcMs(parts, timeZone) {
+    const utcGuess = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+    const offset = getTimeZoneOffsetMs(new Date(utcGuess), timeZone);
+    return utcGuess - offset;
+}
+function getTimeZoneOffsetMs(date, timeZone) {
+    const parts = getZonedParts(date, timeZone);
+    const utcFromParts = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+    return utcFromParts - date.getTime();
+}

package/dist/time.d.cts

@@ -0,0 +1,13 @@
+import type { Timestamp } from "./types.cjs";
+export type Period = 'today' | 'week' | 'sprint' | 'month' | 'quarter';
+export interface TimeRange {
+    start: Timestamp;
+    end: Timestamp;
+    label: string;
+}
+export declare function periodToRange(period: Period, now: Date, timeZone: string): TimeRange;
+export declare function resolveSince(input: string, now: Date): Timestamp;
+export declare function resolveUntil(input: string, now: Date): Timestamp;
+export declare function formatTimestamp(timestamp: Timestamp, timeZone: string): string;
+export declare function diffInDays(start: Timestamp, end: Timestamp): number;
+export declare function parseRelativeDuration(input: string): number;

package/dist/time.d.ts

@@ -0,0 +1,13 @@
+import type { Timestamp } from "./types.js";
+export type Period = 'today' | 'week' | 'sprint' | 'month' | 'quarter';
+export interface TimeRange {
+    start: Timestamp;
+    end: Timestamp;
+    label: string;
+}
+export declare function periodToRange(period: Period, now: Date, timeZone: string): TimeRange;
+export declare function resolveSince(input: string, now: Date): Timestamp;
+export declare function resolveUntil(input: string, now: Date): Timestamp;
+export declare function formatTimestamp(timestamp: Timestamp, timeZone: string): string;
+export declare function diffInDays(start: Timestamp, end: Timestamp): number;
+export declare function parseRelativeDuration(input: string): number;