@0xbigboss/gh-pulse-core 1.0.0 → 1.1.0

package/dist/cache.cjs

@@ -86,6 +86,12 @@ class Cache {
         last_sync INTEGER NOT NULL,
         cursor TEXT
       );
+
+      CREATE TABLE IF NOT EXISTS repo_lists (
+        owner TEXT PRIMARY KEY,
+        repos JSON NOT NULL,
+        fetched_at INTEGER NOT NULL
+      );
     `);
     }
     close() {
@@ -235,6 +241,27 @@ class Cache {
     isFresh(fetchedAt, ttlHours) {
         return fetchedAt >= this.now() - ttlHours * 60 * 60 * 1000;
     }
+    getRepoList(owner) {
+        const row = this.db
+            .query('SELECT repos, fetched_at FROM repo_lists WHERE owner = ?')
+            .get(owner);
+        if (!row) {
+            return null;
+        }
+        return {
+            repos: JSON.parse(row.repos),
+            fetched_at: row.fetched_at,
+        };
+    }
+    upsertRepoList(owner, repos, fetchedAt = this.now()) {
+        this.db.run(`INSERT INTO repo_lists (owner, repos, fetched_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(owner) DO UPDATE SET repos = excluded.repos, fetched_at = excluded.fetched_at`, [owner, JSON.stringify(repos), fetchedAt]);
+    }
+    getCachedRepos() {
+        const rows = this.db.query('SELECT DISTINCT repo FROM sync_state').all();
+        return rows.map((row) => row.repo);
+    }
     eventExists(event, timestamp) {
         switch (event.type) {
             case 'pr_opened':

package/dist/cache.d.cts

@@ -52,6 +52,12 @@ export declare class Cache {
     upsertSyncState(repo: RepoFullName, lastSync: Timestamp, cursor?: string | null): void;
     getFreshness(repos: RepoFullName[]): CacheFreshness;
     isFresh(fetchedAt: Timestamp, ttlHours: number): boolean;
+    getRepoList(owner: string): {
+        repos: RepoFullName[];
+        fetched_at: Timestamp;
+    } | null;
+    upsertRepoList(owner: string, repos: RepoFullName[], fetchedAt?: Timestamp): void;
+    getCachedRepos(): RepoFullName[];
     private eventExists;
 }
 export declare function getEventTimestamp(event: Event): Timestamp;

package/dist/cache.d.ts

@@ -52,6 +52,12 @@ export declare class Cache {
     upsertSyncState(repo: RepoFullName, lastSync: Timestamp, cursor?: string | null): void;
     getFreshness(repos: RepoFullName[]): CacheFreshness;
     isFresh(fetchedAt: Timestamp, ttlHours: number): boolean;
+    getRepoList(owner: string): {
+        repos: RepoFullName[];
+        fetched_at: Timestamp;
+    } | null;
+    upsertRepoList(owner: string, repos: RepoFullName[], fetchedAt?: Timestamp): void;
+    getCachedRepos(): RepoFullName[];
     private eventExists;
 }
 export declare function getEventTimestamp(event: Event): Timestamp;

package/dist/cache.js

@@ -78,6 +78,12 @@ export class Cache {
         last_sync INTEGER NOT NULL,
         cursor TEXT
       );
+
+      CREATE TABLE IF NOT EXISTS repo_lists (
+        owner TEXT PRIMARY KEY,
+        repos JSON NOT NULL,
+        fetched_at INTEGER NOT NULL
+      );
     `);
     }
     close() {
@@ -227,6 +233,27 @@ export class Cache {
     isFresh(fetchedAt, ttlHours) {
         return fetchedAt >= this.now() - ttlHours * 60 * 60 * 1000;
     }
+    getRepoList(owner) {
+        const row = this.db
+            .query('SELECT repos, fetched_at FROM repo_lists WHERE owner = ?')
+            .get(owner);
+        if (!row) {
+            return null;
+        }
+        return {
+            repos: JSON.parse(row.repos),
+            fetched_at: row.fetched_at,
+        };
+    }
+    upsertRepoList(owner, repos, fetchedAt = this.now()) {
+        this.db.run(`INSERT INTO repo_lists (owner, repos, fetched_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(owner) DO UPDATE SET repos = excluded.repos, fetched_at = excluded.fetched_at`, [owner, JSON.stringify(repos), fetchedAt]);
+    }
+    getCachedRepos() {
+        const rows = this.db.query('SELECT DISTINCT repo FROM sync_state').all();
+        return rows.map((row) => row.repo);
+    }
     eventExists(event, timestamp) {
         switch (event.type) {
             case 'pr_opened':

package/dist/config.cjs

@@ -33,11 +33,15 @@ const ThresholdsSchema = zod_1.z
     stale_days: zod_1.z.number().int().positive().default(2),
     stuck_days: zod_1.z.number().int().positive().default(4),
     large_pr_lines: zod_1.z.number().int().positive().default(500),
+    // Max age for blockers - PRs older than this are excluded from blocker list
+    // Set to 0 to disable (show all blockers regardless of age)
+    blocker_max_age_days: zod_1.z.number().int().nonnegative().default(90),
 })
     .default({
     stale_days: 2,
     stuck_days: 4,
     large_pr_lines: 500,
+    blocker_max_age_days: 90,
 });
 const CacheSchema = zod_1.z
     .object({

package/dist/config.d.cts

@@ -33,14 +33,17 @@ declare const ResolvedConfigSchema: z.ZodObject<{
         stale_days: z.ZodDefault<z.ZodNumber>;
         stuck_days: z.ZodDefault<z.ZodNumber>;
         large_pr_lines: z.ZodDefault<z.ZodNumber>;
+        blocker_max_age_days: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     }, {
         stale_days?: number | undefined;
         stuck_days?: number | undefined;
         large_pr_lines?: number | undefined;
+        blocker_max_age_days?: number | undefined;
     }>>;
     timezone: z.ZodDefault<z.ZodString>;
     cache: z.ZodDefault<z.ZodObject<{
@@ -79,6 +82,7 @@ declare const ResolvedConfigSchema: z.ZodObject<{
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     };
     timezone: string;
     cache: {
@@ -107,6 +111,7 @@ declare const ResolvedConfigSchema: z.ZodObject<{
         stale_days?: number | undefined;
         stuck_days?: number | undefined;
         large_pr_lines?: number | undefined;
+        blocker_max_age_days?: number | undefined;
     } | undefined;
     timezone?: string | undefined;
     cache?: {
@@ -164,14 +169,17 @@ export declare const CONFIG_SCHEMA: z.ZodObject<{
         stale_days: z.ZodDefault<z.ZodNumber>;
         stuck_days: z.ZodDefault<z.ZodNumber>;
         large_pr_lines: z.ZodDefault<z.ZodNumber>;
+        blocker_max_age_days: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     }, {
         stale_days?: number | undefined;
         stuck_days?: number | undefined;
         large_pr_lines?: number | undefined;
+        blocker_max_age_days?: number | undefined;
     }>>;
     timezone: z.ZodDefault<z.ZodString>;
     cache: z.ZodDefault<z.ZodObject<{
@@ -207,6 +215,7 @@ export declare const CONFIG_SCHEMA: z.ZodObject<{
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     };
     timezone: string;
     cache: {
@@ -236,6 +245,7 @@ export declare const CONFIG_SCHEMA: z.ZodObject<{
         stale_days?: number | undefined;
         stuck_days?: number | undefined;
         large_pr_lines?: number | undefined;
+        blocker_max_age_days?: number | undefined;
     } | undefined;
     timezone?: string | undefined;
     cache?: {

package/dist/config.d.ts

@@ -33,14 +33,17 @@ declare const ResolvedConfigSchema: z.ZodObject<{
         stale_days: z.ZodDefault<z.ZodNumber>;
         stuck_days: z.ZodDefault<z.ZodNumber>;
         large_pr_lines: z.ZodDefault<z.ZodNumber>;
+        blocker_max_age_days: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     }, {
         stale_days?: number | undefined;
         stuck_days?: number | undefined;
         large_pr_lines?: number | undefined;
+        blocker_max_age_days?: number | undefined;
     }>>;
     timezone: z.ZodDefault<z.ZodString>;
     cache: z.ZodDefault<z.ZodObject<{
@@ -79,6 +82,7 @@ declare const ResolvedConfigSchema: z.ZodObject<{
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     };
     timezone: string;
     cache: {
@@ -107,6 +111,7 @@ declare const ResolvedConfigSchema: z.ZodObject<{
         stale_days?: number | undefined;
         stuck_days?: number | undefined;
         large_pr_lines?: number | undefined;
+        blocker_max_age_days?: number | undefined;
     } | undefined;
     timezone?: string | undefined;
     cache?: {
@@ -164,14 +169,17 @@ export declare const CONFIG_SCHEMA: z.ZodObject<{
         stale_days: z.ZodDefault<z.ZodNumber>;
         stuck_days: z.ZodDefault<z.ZodNumber>;
         large_pr_lines: z.ZodDefault<z.ZodNumber>;
+        blocker_max_age_days: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     }, {
         stale_days?: number | undefined;
         stuck_days?: number | undefined;
         large_pr_lines?: number | undefined;
+        blocker_max_age_days?: number | undefined;
     }>>;
     timezone: z.ZodDefault<z.ZodString>;
     cache: z.ZodDefault<z.ZodObject<{
@@ -207,6 +215,7 @@ export declare const CONFIG_SCHEMA: z.ZodObject<{
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     };
     timezone: string;
     cache: {
@@ -236,6 +245,7 @@ export declare const CONFIG_SCHEMA: z.ZodObject<{
         stale_days?: number | undefined;
         stuck_days?: number | undefined;
         large_pr_lines?: number | undefined;
+        blocker_max_age_days?: number | undefined;
     } | undefined;
     timezone?: string | undefined;
     cache?: {

package/dist/config.js

@@ -23,11 +23,15 @@ const ThresholdsSchema = z
     stale_days: z.number().int().positive().default(2),
     stuck_days: z.number().int().positive().default(4),
     large_pr_lines: z.number().int().positive().default(500),
+    // Max age for blockers - PRs older than this are excluded from blocker list
+    // Set to 0 to disable (show all blockers regardless of age)
+    blocker_max_age_days: z.number().int().nonnegative().default(90),
 })
     .default({
     stale_days: 2,
     stuck_days: 4,
     large_pr_lines: 500,
+    blocker_max_age_days: 90,
 });
 const CacheSchema = z
     .object({

package/dist/reports/exec.cjs

@@ -114,19 +114,40 @@ function buildHighlights(mergedPrs, largePrThreshold, now) {
     })
         .filter((entry) => Boolean(entry));
 }
+/**
+ * Case-insensitive username comparison.
+ */
+function usernameMatches(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+/**
+ * Deduplicate team members case-insensitively, preserving first occurrence.
+ */
+function dedupeMembers(members) {
+    const seen = new Map();
+    for (const member of members) {
+        const key = member.toLowerCase();
+        if (!seen.has(key)) {
+            seen.set(key, member);
+        }
+    }
+    return Array.from(seen.values());
+}
 function buildTeamBreakdown(teamMembers, pullRequests, commits, events, exclude, excludeBots, since, until) {
     const reviewEvents = events.filter((event) => event.type === 'review_submitted');
-    return [...teamMembers]
+    // Dedupe members case-insensitively
+    const uniqueMembers = dedupeMembers(teamMembers);
+    return uniqueMembers
         .filter((member) => !(0, filters_1.isExcludedAuthor)(member, exclude, excludeBots))
         .map((member) => {
-        const authored = pullRequests.filter((pr) => pr.author === member &&
+        const authored = pullRequests.filter((pr) => usernameMatches(pr.author, member) &&
             pr.created_at >= since &&
             pr.created_at <= until &&
             !(0, filters_1.isExcludedAuthor)(pr.author, exclude, excludeBots));
         const reviewed = reviewEvents.filter((event) => event.type === 'review_submitted' &&
-            event.reviewer === member &&
+            usernameMatches(event.reviewer, member) &&
             !(0, filters_1.isExcludedAuthor)(event.reviewer, exclude, excludeBots));
-        const memberCommits = commits.filter((commit) => commit.author === member &&
+        const memberCommits = commits.filter((commit) => usernameMatches(commit.author, member) &&
             commit.committed_at >= since &&
             commit.committed_at <= until &&
             !(0, filters_1.isExcludedAuthor)(commit.author, exclude, excludeBots));

package/dist/reports/exec.js

@@ -111,19 +111,40 @@ function buildHighlights(mergedPrs, largePrThreshold, now) {
     })
         .filter((entry) => Boolean(entry));
 }
+/**
+ * Case-insensitive username comparison.
+ */
+function usernameMatches(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+/**
+ * Deduplicate team members case-insensitively, preserving first occurrence.
+ */
+function dedupeMembers(members) {
+    const seen = new Map();
+    for (const member of members) {
+        const key = member.toLowerCase();
+        if (!seen.has(key)) {
+            seen.set(key, member);
+        }
+    }
+    return Array.from(seen.values());
+}
 function buildTeamBreakdown(teamMembers, pullRequests, commits, events, exclude, excludeBots, since, until) {
     const reviewEvents = events.filter((event) => event.type === 'review_submitted');
-    return [...teamMembers]
+    // Dedupe members case-insensitively
+    const uniqueMembers = dedupeMembers(teamMembers);
+    return uniqueMembers
         .filter((member) => !isExcludedAuthor(member, exclude, excludeBots))
         .map((member) => {
-        const authored = pullRequests.filter((pr) => pr.author === member &&
+        const authored = pullRequests.filter((pr) => usernameMatches(pr.author, member) &&
             pr.created_at >= since &&
             pr.created_at <= until &&
             !isExcludedAuthor(pr.author, exclude, excludeBots));
         const reviewed = reviewEvents.filter((event) => event.type === 'review_submitted' &&
-            event.reviewer === member &&
+            usernameMatches(event.reviewer, member) &&
             !isExcludedAuthor(event.reviewer, exclude, excludeBots));
-        const memberCommits = commits.filter((commit) => commit.author === member &&
+        const memberCommits = commits.filter((commit) => usernameMatches(commit.author, member) &&
             commit.committed_at >= since &&
             commit.committed_at <= until &&
             !isExcludedAuthor(commit.author, exclude, excludeBots));

package/dist/reports/personal.cjs

@@ -4,6 +4,12 @@ exports.buildPersonalReport = buildPersonalReport;
 const utils_1 = require("./utils.cjs");
 const context_1 = require("./context.cjs");
 const filters_1 = require("../filters.cjs");
+/**
+ * Case-insensitive username comparison.
+ */
+function usernameMatches(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
 function buildPersonalReport(cache, options) {
     const { pullRequests, commits } = (0, context_1.loadReportData)(cache, options.repos);
     const now = options.meta.generated_at;
@@ -12,7 +18,8 @@ function buildPersonalReport(cache, options) {
     const events = cache
         .getEvents({ since: options.timeRange.start, until: options.timeRange.end })
         .filter((event) => options.repos.includes(event.repo));
-    const authoredPrs = pullRequests.filter((pr) => pr.author === options.user && !(0, filters_1.isExcludedAuthor)(pr.author, exclude, options.excludeBots));
+    const authoredPrs = pullRequests.filter((pr) => usernameMatches(pr.author, options.user) &&
+        !(0, filters_1.isExcludedAuthor)(pr.author, exclude, options.excludeBots));
     const authoredSummaries = authoredPrs
         .filter((pr) => pr.created_at >= options.timeRange.start && pr.created_at <= options.timeRange.end)
         .map((pr) => (0, utils_1.buildPullRequestSummary)(pr, now));
@@ -23,19 +30,20 @@ function buildPersonalReport(cache, options) {
     const requested = pullRequests
         .filter((pr) => pr.state === 'open')
         .filter((pr) => options.includeDrafts || !pr.draft)
-        .filter((pr) => pr.requested_reviewers.includes(options.user))
+        .filter((pr) => pr.requested_reviewers.some((reviewer) => usernameMatches(reviewer, options.user)))
         .filter((pr) => !(0, filters_1.isExcludedAuthor)(pr.author, exclude, options.excludeBots))
         .map((pr) => (0, utils_1.buildPullRequestSummary)(pr, now));
-    const teamMembers = new Set(options.teamMembers);
+    // Use lowercase keys for case-insensitive membership checks
+    const teamMembers = new Set(options.teamMembers.map((m) => m.toLowerCase()));
     const teamPrs = pullRequests
         .filter((pr) => pr.state === 'open')
         .filter((pr) => options.includeDrafts || !pr.draft)
-        .filter((pr) => pr.author !== options.user)
-        .filter((pr) => teamMembers.has(pr.author))
+        .filter((pr) => !usernameMatches(pr.author, options.user))
+        .filter((pr) => teamMembers.has(pr.author.toLowerCase()))
         .filter((pr) => !(0, filters_1.isExcludedAuthor)(pr.author, exclude, options.excludeBots))
         .map((pr) => (0, utils_1.buildPullRequestSummary)(pr, now));
     const commitsForUser = commits
-        .filter((commit) => commit.author === options.user)
+        .filter((commit) => usernameMatches(commit.author, options.user))
         .filter((commit) => commit.committed_at >= options.timeRange.start)
         .filter((commit) => commit.committed_at <= options.timeRange.end)
         .filter((commit) => !(0, filters_1.isExcludedAuthor)(commit.author, exclude, options.excludeBots));
@@ -67,7 +75,7 @@ function buildPersonalReport(cache, options) {
     };
 }
 function buildPersonalSummary(events, prLookup, user, commits) {
-    const opened = events.filter((event) => event.type === 'pr_opened' && event.author === user);
+    const opened = events.filter((event) => event.type === 'pr_opened' && usernameMatches(event.author, user));
     const merged = events.filter((event) => event.type === 'pr_merged' && prMatchesAuthor(prLookup, event.repo, event.pr_number, user));
     const closed = events.filter((event) => event.type === 'pr_closed' && prMatchesAuthor(prLookup, event.repo, event.pr_number, user));
     const reposTouched = new Set(commits.map((commit) => commit.repo));
@@ -83,7 +91,7 @@ function buildPersonalSummary(events, prLookup, user, commits) {
 }
 function prMatchesAuthor(lookup, repo, number, user) {
     const pr = lookup.get(`${repo}#${number}`);
-    return pr ? pr.author === user : false;
+    return pr ? usernameMatches(pr.author, user) : false;
 }
 function buildPullRequestLookup(pullRequests) {
     return new Map(pullRequests.map((pr) => [`${pr.repo}#${pr.number}`, pr]));

package/dist/reports/personal.js

@@ -1,6 +1,12 @@
 import { buildPullRequestSummary } from "./utils.js";
 import { loadReportData } from "./context.js";
 import { isExcludedAuthor } from "../filters.js";
+/**
+ * Case-insensitive username comparison.
+ */
+function usernameMatches(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
 export function buildPersonalReport(cache, options) {
     const { pullRequests, commits } = loadReportData(cache, options.repos);
     const now = options.meta.generated_at;
@@ -9,7 +15,8 @@ export function buildPersonalReport(cache, options) {
     const events = cache
         .getEvents({ since: options.timeRange.start, until: options.timeRange.end })
         .filter((event) => options.repos.includes(event.repo));
-    const authoredPrs = pullRequests.filter((pr) => pr.author === options.user && !isExcludedAuthor(pr.author, exclude, options.excludeBots));
+    const authoredPrs = pullRequests.filter((pr) => usernameMatches(pr.author, options.user) &&
+        !isExcludedAuthor(pr.author, exclude, options.excludeBots));
     const authoredSummaries = authoredPrs
         .filter((pr) => pr.created_at >= options.timeRange.start && pr.created_at <= options.timeRange.end)
         .map((pr) => buildPullRequestSummary(pr, now));
@@ -20,19 +27,20 @@ export function buildPersonalReport(cache, options) {
     const requested = pullRequests
         .filter((pr) => pr.state === 'open')
         .filter((pr) => options.includeDrafts || !pr.draft)
-        .filter((pr) => pr.requested_reviewers.includes(options.user))
+        .filter((pr) => pr.requested_reviewers.some((reviewer) => usernameMatches(reviewer, options.user)))
         .filter((pr) => !isExcludedAuthor(pr.author, exclude, options.excludeBots))
         .map((pr) => buildPullRequestSummary(pr, now));
-    const teamMembers = new Set(options.teamMembers);
+    // Use lowercase keys for case-insensitive membership checks
+    const teamMembers = new Set(options.teamMembers.map((m) => m.toLowerCase()));
     const teamPrs = pullRequests
         .filter((pr) => pr.state === 'open')
         .filter((pr) => options.includeDrafts || !pr.draft)
-        .filter((pr) => pr.author !== options.user)
-        .filter((pr) => teamMembers.has(pr.author))
+        .filter((pr) => !usernameMatches(pr.author, options.user))
+        .filter((pr) => teamMembers.has(pr.author.toLowerCase()))
         .filter((pr) => !isExcludedAuthor(pr.author, exclude, options.excludeBots))
         .map((pr) => buildPullRequestSummary(pr, now));
     const commitsForUser = commits
-        .filter((commit) => commit.author === options.user)
+        .filter((commit) => usernameMatches(commit.author, options.user))
         .filter((commit) => commit.committed_at >= options.timeRange.start)
         .filter((commit) => commit.committed_at <= options.timeRange.end)
         .filter((commit) => !isExcludedAuthor(commit.author, exclude, options.excludeBots));
@@ -64,7 +72,7 @@ export function buildPersonalReport(cache, options) {
     };
 }
 function buildPersonalSummary(events, prLookup, user, commits) {
-    const opened = events.filter((event) => event.type === 'pr_opened' && event.author === user);
+    const opened = events.filter((event) => event.type === 'pr_opened' && usernameMatches(event.author, user));
     const merged = events.filter((event) => event.type === 'pr_merged' && prMatchesAuthor(prLookup, event.repo, event.pr_number, user));
     const closed = events.filter((event) => event.type === 'pr_closed' && prMatchesAuthor(prLookup, event.repo, event.pr_number, user));
     const reposTouched = new Set(commits.map((commit) => commit.repo));
@@ -80,7 +88,7 @@ function buildPersonalSummary(events, prLookup, user, commits) {
 }
 function prMatchesAuthor(lookup, repo, number, user) {
     const pr = lookup.get(`${repo}#${number}`);
-    return pr ? pr.author === user : false;
+    return pr ? usernameMatches(pr.author, user) : false;
 }
 function buildPullRequestLookup(pullRequests) {
     return new Map(pullRequests.map((pr) => [`${pr.repo}#${pr.number}`, pr]));

package/dist/reports/team.cjs

@@ -8,7 +8,8 @@ function buildTeamReport(cache, options) {
     const { pullRequests, commits } = (0, context_1.loadReportData)(cache, options.repos);
     const now = options.meta.generated_at;
     const exclude = options.excludeAuthors;
-    const teamSet = new Set(options.teamMembers);
+    // Use lowercase keys for case-insensitive membership checks
+    const teamSet = new Set(options.teamMembers.map((m) => m.toLowerCase()));
     const prLookup = buildPullRequestLookup(pullRequests);
     const events = cache
         .getEvents({ since: options.timeRange.start, until: options.timeRange.end })
@@ -43,7 +44,7 @@ function buildTeamReport(cache, options) {
         return { pr: (0, utils_1.buildPullRequestSummary)(pr, now), metrics };
     });
     const memberBreakdown = buildMemberBreakdown(options.teamMembers, pullRequests, commits, reviewEvents, exclude, options.excludeBots, options.timeRange.start, options.timeRange.end);
-    const blockers = findBlockers(pullRequests, options.includeDrafts, exclude, options.excludeBots, options.thresholds, now);
+    const blockers = findBlockers(pullRequests, options.includeDrafts, exclude, options.excludeBots, options.thresholds, now, options.timeRange);
     return {
         type: 'team',
         meta: options.meta,
@@ -63,18 +64,39 @@ function buildTeamReport(cache, options) {
         review_engagement: reviewEngagement,
     };
 }
+/**
+ * Case-insensitive username comparison.
+ */
+function usernameMatches(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+/**
+ * Deduplicate team members case-insensitively, preserving first occurrence.
+ */
+function dedupeMembers(members) {
+    const seen = new Map();
+    for (const member of members) {
+        const key = member.toLowerCase();
+        if (!seen.has(key)) {
+            seen.set(key, member);
+        }
+    }
+    return Array.from(seen.values());
+}
 function buildMemberBreakdown(teamMembers, pullRequests, commits, reviewEvents, exclude, excludeBots, since, until) {
-    return [...teamMembers]
+    // Dedupe members case-insensitively
+    const uniqueMembers = dedupeMembers(teamMembers);
+    return uniqueMembers
         .filter((member) => !(0, filters_1.isExcludedAuthor)(member, exclude, excludeBots))
         .map((member) => {
-        const authored = pullRequests.filter((pr) => pr.author === member &&
+        const authored = pullRequests.filter((pr) => usernameMatches(pr.author, member) &&
             pr.created_at >= since &&
             pr.created_at <= until &&
             !(0, filters_1.isExcludedAuthor)(pr.author, exclude, excludeBots));
         const reviewed = reviewEvents.filter((event) => event.type === 'review_submitted' &&
-            event.reviewer === member &&
+            usernameMatches(event.reviewer, member) &&
             !(0, filters_1.isExcludedAuthor)(event.reviewer, exclude, excludeBots));
-        const memberCommits = commits.filter((commit) => commit.author === member &&
+        const memberCommits = commits.filter((commit) => usernameMatches(commit.author, member) &&
             commit.committed_at >= since &&
             commit.committed_at <= until &&
             !(0, filters_1.isExcludedAuthor)(commit.author, exclude, excludeBots));
@@ -89,11 +111,32 @@ function buildMemberBreakdown(teamMembers, pullRequests, commits, reviewEvents,
     })
         .toSorted((a, b) => a.user.localeCompare(b.user));
 }
-function findBlockers(pullRequests, includeDrafts, exclude, excludeBots, thresholds, now) {
+/**
+ * Find blockers (stale/stuck PRs) with configurable age filtering.
+ *
+ * A PR is included in the blocker list if:
+ * - It had activity (was updated) within the time range, OR
+ * - It was created within the time range, OR
+ * - blocker_max_age_days is 0 (disabled), OR
+ * - The PR is younger than blocker_max_age_days
+ */
+function findBlockers(pullRequests, includeDrafts, exclude, excludeBots, thresholds, now, timeRange) {
+    const maxAgeDays = thresholds.blocker_max_age_days;
     return pullRequests
         .filter((pr) => pr.state === 'open')
         .filter((pr) => includeDrafts || !pr.draft)
         .filter((pr) => !(0, filters_1.isExcludedAuthor)(pr.author, exclude, excludeBots))
+        .filter((pr) => {
+        // If max age is disabled (0), include all
+        if (maxAgeDays === 0)
+            return true;
+        const prAgeDays = diffDays(pr.created_at, now);
+        const hadActivityInRange = pr.updated_at >= timeRange.start && pr.updated_at <= timeRange.end;
+        const createdInRange = pr.created_at >= timeRange.start && pr.created_at <= timeRange.end;
+        const withinMaxAge = prAgeDays <= maxAgeDays;
+        // Include if: had recent activity, was created in range, or is within max age
+        return hadActivityInRange || createdInRange || withinMaxAge;
+    })
         .flatMap((pr) => {
         const blockers = [];
         const summary = (0, utils_1.buildPullRequestSummary)(pr, now);
@@ -112,8 +155,11 @@ function findBlockers(pullRequests, includeDrafts, exclude, excludeBots, thresho
 function diffDays(start, end) {
     return Math.floor((end - start) / (24 * 60 * 60 * 1000));
 }
+/**
+ * Case-insensitive check if author is in team.
+ */
 function teamHasAuthor(team, author) {
-    return team.has(author);
+    return team.has(author.toLowerCase());
 }
 function prAuthorInTeam(lookup, team, repo, number, exclude, excludeBots) {
     const pr = lookup.get(`${repo}#${number}`);

package/dist/reports/team.js

@@ -5,7 +5,8 @@ export function buildTeamReport(cache, options) {
     const { pullRequests, commits } = loadReportData(cache, options.repos);
     const now = options.meta.generated_at;
     const exclude = options.excludeAuthors;
-    const teamSet = new Set(options.teamMembers);
+    // Use lowercase keys for case-insensitive membership checks
+    const teamSet = new Set(options.teamMembers.map((m) => m.toLowerCase()));
     const prLookup = buildPullRequestLookup(pullRequests);
     const events = cache
         .getEvents({ since: options.timeRange.start, until: options.timeRange.end })
@@ -40,7 +41,7 @@ export function buildTeamReport(cache, options) {
         return { pr: buildPullRequestSummary(pr, now), metrics };
     });
     const memberBreakdown = buildMemberBreakdown(options.teamMembers, pullRequests, commits, reviewEvents, exclude, options.excludeBots, options.timeRange.start, options.timeRange.end);
-    const blockers = findBlockers(pullRequests, options.includeDrafts, exclude, options.excludeBots, options.thresholds, now);
+    const blockers = findBlockers(pullRequests, options.includeDrafts, exclude, options.excludeBots, options.thresholds, now, options.timeRange);
     return {
         type: 'team',
         meta: options.meta,
@@ -60,18 +61,39 @@ export function buildTeamReport(cache, options) {
         review_engagement: reviewEngagement,
     };
 }
+/**
+ * Case-insensitive username comparison.
+ */
+function usernameMatches(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+/**
+ * Deduplicate team members case-insensitively, preserving first occurrence.
+ */
+function dedupeMembers(members) {
+    const seen = new Map();
+    for (const member of members) {
+        const key = member.toLowerCase();
+        if (!seen.has(key)) {
+            seen.set(key, member);
+        }
+    }
+    return Array.from(seen.values());
+}
 function buildMemberBreakdown(teamMembers, pullRequests, commits, reviewEvents, exclude, excludeBots, since, until) {
-    return [...teamMembers]
+    // Dedupe members case-insensitively
+    const uniqueMembers = dedupeMembers(teamMembers);
+    return uniqueMembers
         .filter((member) => !isExcludedAuthor(member, exclude, excludeBots))
         .map((member) => {
-        const authored = pullRequests.filter((pr) => pr.author === member &&
+        const authored = pullRequests.filter((pr) => usernameMatches(pr.author, member) &&
             pr.created_at >= since &&
             pr.created_at <= until &&
             !isExcludedAuthor(pr.author, exclude, excludeBots));
         const reviewed = reviewEvents.filter((event) => event.type === 'review_submitted' &&
-            event.reviewer === member &&
+            usernameMatches(event.reviewer, member) &&
             !isExcludedAuthor(event.reviewer, exclude, excludeBots));
-        const memberCommits = commits.filter((commit) => commit.author === member &&
+        const memberCommits = commits.filter((commit) => usernameMatches(commit.author, member) &&
             commit.committed_at >= since &&
             commit.committed_at <= until &&
             !isExcludedAuthor(commit.author, exclude, excludeBots));
@@ -86,11 +108,32 @@ function buildMemberBreakdown(teamMembers, pullRequests, commits, reviewEvents,
     })
         .toSorted((a, b) => a.user.localeCompare(b.user));
 }
-function findBlockers(pullRequests, includeDrafts, exclude, excludeBots, thresholds, now) {
+/**
+ * Find blockers (stale/stuck PRs) with configurable age filtering.
+ *
+ * A PR is included in the blocker list if:
+ * - It had activity (was updated) within the time range, OR
+ * - It was created within the time range, OR
+ * - blocker_max_age_days is 0 (disabled), OR
+ * - The PR is younger than blocker_max_age_days
+ */
+function findBlockers(pullRequests, includeDrafts, exclude, excludeBots, thresholds, now, timeRange) {
+    const maxAgeDays = thresholds.blocker_max_age_days;
     return pullRequests
         .filter((pr) => pr.state === 'open')
         .filter((pr) => includeDrafts || !pr.draft)
         .filter((pr) => !isExcludedAuthor(pr.author, exclude, excludeBots))
+        .filter((pr) => {
+        // If max age is disabled (0), include all
+        if (maxAgeDays === 0)
+            return true;
+        const prAgeDays = diffDays(pr.created_at, now);
+        const hadActivityInRange = pr.updated_at >= timeRange.start && pr.updated_at <= timeRange.end;
+        const createdInRange = pr.created_at >= timeRange.start && pr.created_at <= timeRange.end;
+        const withinMaxAge = prAgeDays <= maxAgeDays;
+        // Include if: had recent activity, was created in range, or is within max age
+        return hadActivityInRange || createdInRange || withinMaxAge;
+    })
         .flatMap((pr) => {
         const blockers = [];
         const summary = buildPullRequestSummary(pr, now);
@@ -109,8 +152,11 @@ function findBlockers(pullRequests, includeDrafts, exclude, excludeBots, thresho
 function diffDays(start, end) {
     return Math.floor((end - start) / (24 * 60 * 60 * 1000));
 }
+/**
+ * Case-insensitive check if author is in team.
+ */
 function teamHasAuthor(team, author) {
-    return team.has(author);
+    return team.has(author.toLowerCase());
 }
 function prAuthorInTeam(lookup, team, repo, number, exclude, excludeBots) {
     const pr = lookup.get(`${repo}#${number}`);

package/dist/reports/types.d.cts

@@ -136,6 +136,7 @@ export interface ReportInputs {
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     };
 }
 export interface ReportDataContext {

package/dist/reports/types.d.ts

@@ -136,6 +136,7 @@ export interface ReportInputs {
         stale_days: number;
         stuck_days: number;
         large_pr_lines: number;
+        blocker_max_age_days: number;
     };
 }
 export interface ReportDataContext {

package/dist/repos.cjs

@@ -8,9 +8,25 @@ const picomatch_1 = __importDefault(require("picomatch"));
 async function resolveRepos(options) {
     const orgs = uniqueStrings([...(options.config.orgs ?? []), ...(options.orgs ?? [])]);
     const repoPatterns = options.repoPatterns ?? [];
+    const { cache, forceSync } = options;
+    const cacheTtlHours = options.config.cache.ttl_hours;
     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()) {
+        // Check cache first (unless forceSync)
+        if (cache && !forceSync) {
+            const cached = cache.getRepoList(org);
+            if (cached && cache.isFresh(cached.fetched_at, cacheTtlHours)) {
+                options.onProgress?.({
+                    phase: 'resolve',
+                    message: `Using cached repos for ${org}`,
+                    current: index + 1,
+                    total: orgs.length,
+                });
+                cached.repos.forEach((repo) => repoSet.add(repo));
+                continue;
+            }
+        }
         options.onProgress?.({
             phase: 'resolve',
             message: `Resolving repos for ${org}`,
@@ -19,6 +35,10 @@ async function resolveRepos(options) {
         });
         const repos = await listOwnerRepos(options.github, org);
         repos.forEach((repo) => repoSet.add(repo));
+        // Cache the result
+        if (cache) {
+            cache.upsertRepoList(org, repos);
+        }
     }
     for (const pattern of options.config.repos ?? []) {
         if (pattern.includes('*')) {
@@ -26,11 +46,36 @@ async function resolveRepos(options) {
             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);
+            // Check cache first (unless forceSync)
+            let repos;
+            if (cache && !forceSync) {
+                const cached = cache.getRepoList(owner);
+                if (cached && cache.isFresh(cached.fetched_at, cacheTtlHours)) {
+                    options.onProgress?.({
+                        phase: 'resolve',
+                        message: `Using cached repos for ${owner}`,
+                    });
+                    repos = cached.repos;
+                }
+                else {
+                    options.onProgress?.({
+                        phase: 'resolve',
+                        message: `Resolving repos for ${owner}`,
+                    });
+                    repos = await listOwnerRepos(options.github, owner);
+                    cache.upsertRepoList(owner, repos);
+                }
+            }
+            else {
+                options.onProgress?.({
+                    phase: 'resolve',
+                    message: `Resolving repos for ${owner}`,
+                });
+                repos = await listOwnerRepos(options.github, owner);
+                if (cache) {
+                    cache.upsertRepoList(owner, repos);
+                }
+            }
             const matcher = (0, picomatch_1.default)(pattern);
             repos.filter((repo) => matcher(repo)).forEach((repo) => repoSet.add(repo));
             continue;

package/dist/repos.d.cts

@@ -1,12 +1,15 @@
+import type { Cache } from "./cache.cjs";
 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;
+    cache?: Cache;
     orgs?: string[];
     repoPatterns?: string[];
     strict?: boolean;
+    forceSync?: boolean;
     onProgress?: (event: ProgressEvent) => void;
 }
 export declare function resolveRepos(options: ResolveReposOptions): Promise<RepoFullName[]>;

package/dist/repos.d.ts

@@ -1,12 +1,15 @@
+import type { Cache } from "./cache.js";
 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;
+    cache?: Cache;
     orgs?: string[];
     repoPatterns?: string[];
     strict?: boolean;
+    forceSync?: boolean;
     onProgress?: (event: ProgressEvent) => void;
 }
 export declare function resolveRepos(options: ResolveReposOptions): Promise<RepoFullName[]>;

package/dist/repos.js

@@ -2,9 +2,25 @@ import picomatch from 'picomatch';
 export async function resolveRepos(options) {
     const orgs = uniqueStrings([...(options.config.orgs ?? []), ...(options.orgs ?? [])]);
     const repoPatterns = options.repoPatterns ?? [];
+    const { cache, forceSync } = options;
+    const cacheTtlHours = options.config.cache.ttl_hours;
     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()) {
+        // Check cache first (unless forceSync)
+        if (cache && !forceSync) {
+            const cached = cache.getRepoList(org);
+            if (cached && cache.isFresh(cached.fetched_at, cacheTtlHours)) {
+                options.onProgress?.({
+                    phase: 'resolve',
+                    message: `Using cached repos for ${org}`,
+                    current: index + 1,
+                    total: orgs.length,
+                });
+                cached.repos.forEach((repo) => repoSet.add(repo));
+                continue;
+            }
+        }
         options.onProgress?.({
             phase: 'resolve',
             message: `Resolving repos for ${org}`,
@@ -13,6 +29,10 @@ export async function resolveRepos(options) {
         });
         const repos = await listOwnerRepos(options.github, org);
         repos.forEach((repo) => repoSet.add(repo));
+        // Cache the result
+        if (cache) {
+            cache.upsertRepoList(org, repos);
+        }
     }
     for (const pattern of options.config.repos ?? []) {
         if (pattern.includes('*')) {
@@ -20,11 +40,36 @@ export async function resolveRepos(options) {
             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);
+            // Check cache first (unless forceSync)
+            let repos;
+            if (cache && !forceSync) {
+                const cached = cache.getRepoList(owner);
+                if (cached && cache.isFresh(cached.fetched_at, cacheTtlHours)) {
+                    options.onProgress?.({
+                        phase: 'resolve',
+                        message: `Using cached repos for ${owner}`,
+                    });
+                    repos = cached.repos;
+                }
+                else {
+                    options.onProgress?.({
+                        phase: 'resolve',
+                        message: `Resolving repos for ${owner}`,
+                    });
+                    repos = await listOwnerRepos(options.github, owner);
+                    cache.upsertRepoList(owner, repos);
+                }
+            }
+            else {
+                options.onProgress?.({
+                    phase: 'resolve',
+                    message: `Resolving repos for ${owner}`,
+                });
+                repos = await listOwnerRepos(options.github, owner);
+                if (cache) {
+                    cache.upsertRepoList(owner, repos);
+                }
+            }
             const matcher = picomatch(pattern);
             repos.filter((repo) => matcher(repo)).forEach((repo) => repoSet.add(repo));
             continue;

package/dist/team.cjs

@@ -21,8 +21,19 @@ async function resolveTeamMembers(options) {
         }
     }
 }
+/**
+ * Deduplicate usernames case-insensitively.
+ * Preserves the first occurrence's casing (typically the canonical GitHub casing).
+ */
 function unique(values) {
-    return Array.from(new Set(values));
+    const seen = new Map();
+    for (const value of values) {
+        const key = value.toLowerCase();
+        if (!seen.has(key)) {
+            seen.set(key, value);
+        }
+    }
+    return Array.from(seen.values());
 }
 async function listOwnerMembers(github, owner) {
     try {

package/dist/team.js

@@ -18,8 +18,19 @@ export async function resolveTeamMembers(options) {
         }
     }
 }
+/**
+ * Deduplicate usernames case-insensitively.
+ * Preserves the first occurrence's casing (typically the canonical GitHub casing).
+ */
 function unique(values) {
-    return Array.from(new Set(values));
+    const seen = new Map();
+    for (const value of values) {
+        const key = value.toLowerCase();
+        if (!seen.has(key)) {
+            seen.set(key, value);
+        }
+    }
+    return Array.from(seen.values());
 }
 async function listOwnerMembers(github, owner) {
     try {

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@0xbigboss/gh-pulse-core",
-  "version": "1.0.0",
+  "version": "1.1.0",
+  "license": "MIT",
   "files": [
     "dist"
   ],