claude-git-hooks 2.30.1 → 2.32.0

package/lib/utils/remote-config.js

@@ -0,0 +1,102 @@
+/**
+ * File: remote-config.js
+ * Purpose: Generic fetcher for JSON config files from the centralized config repo
+ *
+ * Design:
+ * - Fetches JSON files from mscope-S-L/git-hooks-config via GitHub API
+ * - In-memory cache per process (Map<string, Object|null>) — stores null for failures (no retry)
+ * - Graceful degradation: any error → warn + return null (callers decide fallback)
+ * - No schema validation (callers validate their own shape)
+ * - Debug logging at every step
+ */
+
+import logger from './logger.js';
+import { fetchFileContent } from './github-api.js';
+
+/** @type {string} Owner of the centralized config repository */
+export const CONFIG_REPO_OWNER = 'mscope-S-L';
+
+/** @type {string} Name of the centralized config repository */
+export const CONFIG_REPO_NAME = 'git-hooks-config';
+
+/**
+ * In-memory cache: fileName → parsed Object (or null on failure).
+ * Persists for the lifetime of the process — avoids repeated API calls.
+ * Null entries are cached intentionally: a failed fetch won't succeed on retry
+ * within the same CLI invocation.
+ * @type {Map<string, Object|null>}
+ */
+const _cache = new Map();
+
+/**
+ * Fetch and parse a JSON config file from the centralized config repo.
+ *
+ * @param {string} fileName - File path within the config repo (e.g. 'labels.json')
+ * @returns {Promise<Object|null>} Parsed JSON object, or null on any failure
+ */
+export async function fetchRemoteConfig(fileName) {
+    logger.debug('remote-config - fetchRemoteConfig', 'Request received', { fileName });
+
+    // Cache hit (includes cached nulls)
+    if (_cache.has(fileName)) {
+        const cached = _cache.get(fileName);
+        logger.debug('remote-config - fetchRemoteConfig', 'Cache hit', {
+            fileName,
+            hasValue: cached !== null
+        });
+        return cached;
+    }
+
+    // Fetch from GitHub
+    let content;
+    try {
+        content = await fetchFileContent(CONFIG_REPO_OWNER, CONFIG_REPO_NAME, fileName);
+    } catch (err) {
+        logger.warning(`Could not fetch remote config '${fileName}': ${err.message}`);
+        logger.debug('remote-config - fetchRemoteConfig', 'fetchFileContent threw', {
+            fileName,
+            error: err.message
+        });
+        _cache.set(fileName, null);
+        return null;
+    }
+
+    if (content === null || content === undefined) {
+        logger.warning(`Remote config '${fileName}' not found in ${CONFIG_REPO_OWNER}/${CONFIG_REPO_NAME}`);
+        logger.debug('remote-config - fetchRemoteConfig', 'fetchFileContent returned null', {
+            fileName
+        });
+        _cache.set(fileName, null);
+        return null;
+    }
+
+    // Parse JSON
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    } catch (err) {
+        logger.warning(`Remote config '${fileName}' contains invalid JSON: ${err.message}`);
+        logger.debug('remote-config - fetchRemoteConfig', 'JSON.parse failed', {
+            fileName,
+            error: err.message,
+            contentPreview: String(content).substring(0, 100)
+        });
+        _cache.set(fileName, null);
+        return null;
+    }
+
+    logger.debug('remote-config - fetchRemoteConfig', 'Successfully fetched and parsed', {
+        fileName,
+        keys: Object.keys(parsed)
+    });
+
+    _cache.set(fileName, parsed);
+    return parsed;
+}
+
+/**
+ * Clear the in-memory cache. Test helper — not intended for production use.
+ */
+export function _clearCache() {
+    _cache.clear();
+}

package/lib/utils/reviewer-selector.js

@@ -0,0 +1,154 @@
+/**
+ * File: reviewer-selector.js
+ * Purpose: Team-based reviewer selection for Pull Requests
+ *
+ * Resolves team members via GitHub Teams API, excludes the PR author
+ * and excluded reviewers (from remote config.json + local config),
+ * and returns eligible reviewers. Falls back to config-based reviewers
+ * if team resolution fails.
+ *
+ * Exclusion sources (merged, deduplicated):
+ * 1. Remote: config.json → general.github.pr.excludeReviewers (all repos)
+ * 2. Remote: config.json → {repoFullName}.github.pr.excludeReviewers (repo-specific)
+ * 3. Local: config.github.pr.excludeReviewers (per-repo override)
+ * 4. PR author (always excluded)
+ *
+ * Merge priority: remote general < remote repo-specific < local overrides
+ *
+ * Design: teamSlug is an explicit parameter (default: 'automation').
+ * Future auto-detection (e.g. from repos.listTeams) can be plugged in
+ * by the caller without changing this module.
+ */
+
+import logger from './logger.js';
+import { listTeamMembers } from './github-api.js';
+import { fetchRemoteConfig } from './remote-config.js';
+
+/** Default team slug — single place to change when auto-detection is added */
+const DEFAULT_TEAM = 'automation';
+
+/**
+ * Build the merged exclusion set from remote config.json + local config.
+ *
+ * @param {string} repoFullName - Full repo name (e.g. 'mscope-S-L/git-hooks')
+ * @param {string[]} localExclude - Local excludeReviewers array from config
+ * @returns {Promise<Set<string>>} Set of usernames to exclude
+ */
+export async function _buildExclusionSet(repoFullName, localExclude = []) {
+    const excluded = new Set();
+
+    // Remote config: general + repo-specific
+    try {
+        const remoteConfig = await fetchRemoteConfig('config.json');
+        if (remoteConfig) {
+            const generalExclude =
+                remoteConfig.general?.github?.pr?.excludeReviewers || [];
+            const repoExclude =
+                remoteConfig[repoFullName]?.github?.pr?.excludeReviewers || [];
+
+            generalExclude.forEach((u) => excluded.add(u));
+            repoExclude.forEach((u) => excluded.add(u));
+
+            logger.debug('reviewer-selector - _buildExclusionSet', 'Remote exclusions loaded', {
+                generalCount: generalExclude.length,
+                repoSpecificCount: repoExclude.length,
+                repoFullName
+            });
+        }
+    } catch (err) {
+        logger.debug('reviewer-selector - _buildExclusionSet', 'Remote config fetch failed', {
+            error: err.message
+        });
+    }
+
+    // Local overrides (highest priority, additive)
+    localExclude.forEach((u) => excluded.add(u));
+
+    logger.debug('reviewer-selector - _buildExclusionSet', 'Final exclusion set', {
+        count: excluded.size,
+        users: [...excluded]
+    });
+
+    return excluded;
+}
+
+/**
+ * Select reviewers for a Pull Request from a GitHub team
+ *
+ * @param {Object} options
+ * @param {string} options.org - GitHub organization (e.g. 'mscope-S-L')
+ * @param {string} options.repoFullName - Full repo name (e.g. 'mscope-S-L/git-hooks')
+ * @param {string} [options.teamSlug='automation'] - Team slug to resolve members from
+ * @param {string} options.prAuthor - PR author login (excluded from selection)
+ * @param {string[]} [options.configReviewers=[]] - Fallback reviewers from config
+ * @param {string[]} [options.excludeReviewers=[]] - Local exclude list from config
+ * @returns {Promise<string[]>} Selected reviewer logins
+ */
+export async function selectReviewers({
+    org,
+    repoFullName,
+    teamSlug = DEFAULT_TEAM,
+    prAuthor,
+    configReviewers = [],
+    excludeReviewers = []
+}) {
+    logger.debug('reviewer-selector - selectReviewers', 'Starting reviewer selection', {
+        org,
+        repoFullName,
+        teamSlug,
+        prAuthor,
+        configReviewersCount: configReviewers.length,
+        localExcludeCount: excludeReviewers.length
+    });
+
+    // Build merged exclusion set (remote general + remote repo-specific + local)
+    const exclusionSet = await _buildExclusionSet(repoFullName, excludeReviewers);
+    // Always exclude the PR author
+    exclusionSet.add(prAuthor);
+
+    // Try team-based resolution
+    try {
+        const members = await listTeamMembers(org, teamSlug);
+        const eligible = members
+            .map((m) => m.login)
+            .filter((login) => !exclusionSet.has(login));
+
+        logger.debug('reviewer-selector - selectReviewers', 'Team members resolved', {
+            teamSlug,
+            totalMembers: members.length,
+            eligibleCount: eligible.length,
+            excludedCount: members.length - eligible.length
+        });
+
+        if (eligible.length > 0) {
+            logger.info(
+                `📋 Found ${eligible.length} reviewer(s) from team '${teamSlug}': ${eligible.join(', ')}`
+            );
+            return eligible;
+        }
+
+        logger.debug(
+            'reviewer-selector - selectReviewers',
+            'No eligible team members, falling back to config'
+        );
+    } catch (err) {
+        logger.warning(
+            `⚠️  Could not resolve team '${teamSlug}': ${err.message}. Falling back to config reviewers.`
+        );
+        logger.debug('reviewer-selector - selectReviewers', 'Team resolution failed', {
+            error: err.message,
+            teamSlug
+        });
+    }
+
+    // Fallback: config-based reviewers
+    const fallback = configReviewers.filter((r) => !exclusionSet.has(r));
+
+    if (fallback.length > 0) {
+        logger.info(`📋 Found ${fallback.length} reviewer(s) from config: ${fallback.join(', ')}`);
+    } else {
+        logger.info('📋 Found 0 reviewer(s): none');
+    }
+
+    return fallback;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-git-hooks",
-    "version": "2.30.1",
+    "version": "2.32.0",
     "description": "Git hooks with Claude CLI for code analysis and automatic commit messages",
     "type": "module",
     "bin": {