@0xbigboss/gh-pulse-core 1.0.0

package/dist/cache.js

@@ -0,0 +1,303 @@
+import { Database } from 'bun:sqlite';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+export class Cache {
+    db;
+    now;
+    constructor(db, now) {
+        this.db = db;
+        this.now = now;
+    }
+    static async open(options) {
+        await ensureDir(options.path);
+        const db = new Database(options.path);
+        const cache = new Cache(db, options.now ?? (() => Date.now()));
+        cache.init();
+        return cache;
+    }
+    init() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL,
+        repo TEXT NOT NULL,
+        payload JSON NOT NULL,
+        timestamp INTEGER NOT NULL,
+        fetched_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+      CREATE INDEX IF NOT EXISTS idx_events_repo ON events(repo);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+
+      CREATE TABLE IF NOT EXISTS pull_requests (
+        repo TEXT NOT NULL,
+        number INTEGER NOT NULL,
+        data JSON NOT NULL,
+        fetched_at INTEGER NOT NULL,
+        PRIMARY KEY (repo, number)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pr_author ON pull_requests((json_extract(data, '$.author')));
+      CREATE INDEX IF NOT EXISTS idx_pr_state ON pull_requests((json_extract(data, '$.state')));
+
+      CREATE TABLE IF NOT EXISTS commits (
+        repo TEXT NOT NULL,
+        sha TEXT NOT NULL,
+        data JSON NOT NULL,
+        fetched_at INTEGER NOT NULL,
+        PRIMARY KEY (repo, sha)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_commits_author ON commits((json_extract(data, '$.author')));
+      CREATE INDEX IF NOT EXISTS idx_commits_timestamp ON commits((json_extract(data, '$.committed_at')));
+
+      CREATE TABLE IF NOT EXISTS linear_issues (
+        id TEXT PRIMARY KEY,
+        data JSON NOT NULL,
+        fetched_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_linear_state ON linear_issues((json_extract(data, '$.state')));
+
+      CREATE TABLE IF NOT EXISTS pr_issue_links (
+        repo TEXT NOT NULL,
+        pr_number INTEGER NOT NULL,
+        issue_id TEXT NOT NULL,
+        correlation_method TEXT NOT NULL,
+        PRIMARY KEY (repo, pr_number, issue_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS sync_state (
+        repo TEXT PRIMARY KEY,
+        last_sync INTEGER NOT NULL,
+        cursor TEXT
+      );
+    `);
+    }
+    close() {
+        this.db.close();
+    }
+    insertEvent(event, fetchedAt = this.now()) {
+        const timestamp = getEventTimestamp(event);
+        if (this.eventExists(event, timestamp)) {
+            return false;
+        }
+        this.db.run('INSERT INTO events (type, repo, payload, timestamp, fetched_at) VALUES (?, ?, ?, ?, ?)', [event.type, event.repo, JSON.stringify(event), timestamp, fetchedAt]);
+        return true;
+    }
+    upsertPullRequest(pr, fetchedAt = this.now()) {
+        this.db.run(`INSERT INTO pull_requests (repo, number, data, fetched_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(repo, number) DO UPDATE SET data = excluded.data, fetched_at = excluded.fetched_at`, [pr.repo, pr.number, JSON.stringify(pr), fetchedAt]);
+    }
+    upsertCommit(commit, fetchedAt = this.now()) {
+        this.db.run(`INSERT INTO commits (repo, sha, data, fetched_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(repo, sha) DO UPDATE SET data = excluded.data, fetched_at = excluded.fetched_at`, [commit.repo, commit.sha, JSON.stringify(commit), fetchedAt]);
+    }
+    getPullRequest(repo, number) {
+        const row = this.db
+            .query('SELECT data, fetched_at FROM pull_requests WHERE repo = ? AND number = ?')
+            .get(repo, number);
+        if (!row) {
+            return null;
+        }
+        return {
+            data: JSON.parse(row.data),
+            fetched_at: row.fetched_at,
+        };
+    }
+    getPullRequests(filter = {}) {
+        const conditions = [];
+        const params = [];
+        if (filter.repo) {
+            conditions.push('repo = ?');
+            params.push(filter.repo);
+        }
+        if (filter.author) {
+            conditions.push("json_extract(data, '$.author') = ?");
+            params.push(filter.author);
+        }
+        if (filter.state) {
+            conditions.push("json_extract(data, '$.state') = ?");
+            params.push(filter.state);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const rows = this.db.query(`SELECT data FROM pull_requests ${where}`).all(...params);
+        return rows.map((row) => JSON.parse(row.data));
+    }
+    getCommits(filter = {}) {
+        const conditions = [];
+        const params = [];
+        if (filter.repo) {
+            conditions.push('repo = ?');
+            params.push(filter.repo);
+        }
+        if (filter.author) {
+            conditions.push("json_extract(data, '$.author') = ?");
+            params.push(filter.author);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const rows = this.db.query(`SELECT data FROM commits ${where}`).all(...params);
+        return rows.map((row) => JSON.parse(row.data));
+    }
+    getCommit(repo, sha) {
+        const row = this.db
+            .query('SELECT data, fetched_at FROM commits WHERE repo = ? AND sha = ?')
+            .get(repo, sha);
+        if (!row) {
+            return null;
+        }
+        return {
+            data: JSON.parse(row.data),
+            fetched_at: row.fetched_at,
+        };
+    }
+    getEvents(filter = {}) {
+        const conditions = [];
+        const params = [];
+        if (filter.repo) {
+            conditions.push('repo = ?');
+            params.push(filter.repo);
+        }
+        if (filter.type) {
+            conditions.push('type = ?');
+            params.push(filter.type);
+        }
+        if (filter.since !== undefined) {
+            conditions.push('timestamp >= ?');
+            params.push(filter.since);
+        }
+        if (filter.until !== undefined) {
+            conditions.push('timestamp <= ?');
+            params.push(filter.until);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const rows = this.db
+            .query(`SELECT payload FROM events ${where} ORDER BY timestamp ASC`)
+            .all(...params);
+        return rows.map((row) => JSON.parse(row.payload));
+    }
+    getEventsForPr(repo, prNumber) {
+        const rows = this.db
+            .query("SELECT payload FROM events WHERE repo = ? AND json_extract(payload, '$.pr_number') = ? ORDER BY timestamp ASC")
+            .all(repo, prNumber);
+        return rows.map((row) => JSON.parse(row.payload));
+    }
+    getSyncState(repo) {
+        const row = this.db
+            .query('SELECT repo, last_sync, cursor FROM sync_state WHERE repo = ?')
+            .get(repo);
+        if (!row) {
+            return null;
+        }
+        return {
+            repo: row.repo,
+            last_sync: row.last_sync,
+            cursor: row.cursor,
+        };
+    }
+    upsertSyncState(repo, lastSync, cursor = null) {
+        this.db.run(`INSERT INTO sync_state (repo, last_sync, cursor)
+       VALUES (?, ?, ?)
+       ON CONFLICT(repo) DO UPDATE SET last_sync = excluded.last_sync, cursor = excluded.cursor`, [repo, lastSync, cursor]);
+    }
+    getFreshness(repos) {
+        const now = this.now();
+        const eventsMax = this.db.query('SELECT MAX(fetched_at) as max FROM events').get();
+        const prMax = this.db.query('SELECT MAX(fetched_at) as max FROM pull_requests').get();
+        const commitMax = this.db.query('SELECT MAX(fetched_at) as max FROM commits').get();
+        const values = [eventsMax?.max ?? null, prMax?.max ?? null, commitMax?.max ?? null].filter((value) => typeof value === 'number');
+        const dataAsOf = values.length > 0 ? Math.max(...values) : null;
+        const cacheAgeMinutes = dataAsOf !== null ? Math.floor((now - dataAsOf) / 60000) : null;
+        const syncedRows = this.db.query('SELECT COUNT(*) as count FROM sync_state').get();
+        return {
+            dataAsOf,
+            cacheAgeMinutes,
+            reposSynced: syncedRows.count,
+            totalRepos: repos.length,
+        };
+    }
+    isFresh(fetchedAt, ttlHours) {
+        return fetchedAt >= this.now() - ttlHours * 60 * 60 * 1000;
+    }
+    eventExists(event, timestamp) {
+        switch (event.type) {
+            case 'pr_opened':
+            case 'pr_ready':
+            case 'pr_merged':
+            case 'pr_closed':
+            case 'review_submitted':
+            case 'comment_added': {
+                const prNumber = 'pr_number' in event ? event.pr_number : null;
+                if (prNumber === null) {
+                    return false;
+                }
+                const row = this.db
+                    .query("SELECT 1 FROM events WHERE type = ? AND repo = ? AND timestamp = ? AND json_extract(payload, '$.pr_number') = ?")
+                    .get(event.type, event.repo, timestamp, prNumber);
+                return Boolean(row);
+            }
+            case 'commit_pushed': {
+                const row = this.db
+                    .query("SELECT 1 FROM events WHERE type = ? AND repo = ? AND json_extract(payload, '$.sha') = ?")
+                    .get(event.type, event.repo, event.sha);
+                return Boolean(row);
+            }
+            default: {
+                const _exhaustive = event;
+                throw new Error(`Unhandled event type: ${_exhaustive}`);
+            }
+        }
+    }
+}
+export function getEventTimestamp(event) {
+    switch (event.type) {
+        case 'pr_opened':
+            return event.opened_at;
+        case 'pr_ready':
+            return event.ready_at;
+        case 'pr_merged':
+            return event.merged_at;
+        case 'pr_closed':
+            return event.closed_at;
+        case 'review_submitted':
+            return event.submitted_at;
+        case 'comment_added':
+            return event.commented_at;
+        case 'commit_pushed':
+            return event.committed_at;
+        default: {
+            const _exhaustive = event;
+            throw new Error(`Unhandled event type: ${_exhaustive}`);
+        }
+    }
+}
+function isSqliteMemoryPath(dbPath) {
+    return dbPath === ':memory:' || dbPath === '';
+}
+async function ensureDir(dbPath) {
+    if (isSqliteMemoryPath(dbPath)) {
+        return;
+    }
+    const dir = path.dirname(dbPath);
+    await fs.mkdir(dir, { recursive: true });
+}
+export function toCommitFromEvent(event) {
+    return {
+        repo: event.repo,
+        sha: event.sha,
+        author: event.author,
+        committed_at: event.committed_at,
+        message: event.message,
+        additions: event.additions,
+        deletions: event.deletions,
+        files_changed: event.files_changed,
+    };
+}

package/dist/config.cjs

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_SCHEMA = exports.DEFAULT_CONFIG_ENV = void 0;
+exports.getGhCliToken = getGhCliToken;
+exports.resolveConfigPath = resolveConfigPath;
+exports.resolveCachePath = resolveCachePath;
+exports.loadConfig = loadConfig;
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const zod_1 = require("zod");
+const yaml_1 = __importDefault(require("yaml"));
+const TeamStrategySchema = zod_1.z.enum(['org_members', 'config_list', 'repo_contributors']);
+const ExcludeSchema = zod_1.z
+    .object({
+    bots: zod_1.z.boolean().default(true),
+    forks: zod_1.z.boolean().default(true),
+    archived: zod_1.z.boolean().default(true),
+    authors: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+})
+    .default({
+    bots: true,
+    forks: true,
+    archived: true,
+    authors: [],
+});
+const ThresholdsSchema = zod_1.z
+    .object({
+    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),
+})
+    .default({
+    stale_days: 2,
+    stuck_days: 4,
+    large_pr_lines: 500,
+});
+const CacheSchema = zod_1.z
+    .object({
+    path: zod_1.z.string().default(''),
+    ttl_hours: zod_1.z.number().int().positive().default(1),
+    sync_ttl_hours: zod_1.z.number().int().nonnegative().default(24),
+    concurrency: zod_1.z.number().int().positive().default(5),
+})
+    .default({
+    path: '',
+    ttl_hours: 1,
+    sync_ttl_hours: 24,
+    concurrency: 5,
+});
+const TeamSchema = zod_1.z
+    .object({
+    strategy: TeamStrategySchema.default('org_members'),
+    members: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+})
+    .default({
+    strategy: 'org_members',
+    members: [],
+});
+const ConfigSchema = zod_1.z.object({
+    github_token: zod_1.z.string().optional(),
+    linear_api_key: zod_1.z.string().min(1).optional(),
+    orgs: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    repos: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+    team: TeamSchema,
+    exclude: ExcludeSchema,
+    thresholds: ThresholdsSchema,
+    timezone: zod_1.z.string().default(''),
+    cache: CacheSchema,
+});
+// Internal schema with required token (after resolution)
+const ResolvedConfigSchema = ConfigSchema.extend({
+    github_token: zod_1.z.string().min(1),
+});
+exports.DEFAULT_CONFIG_ENV = 'GH_PULSE_CONFIG';
+/**
+ * Try to get GitHub token from `gh` CLI.
+ * Returns undefined if gh is not available or not authenticated.
+ */
+function getGhCliToken() {
+    try {
+        const token = (0, node_child_process_1.execSync)('gh auth token', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5000,
+        }).trim();
+        return token.length > 0 ? token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveConfigPath(providedPath, env = process.env) {
+    if (providedPath) {
+        return expandHome(providedPath);
+    }
+    const envPath = env[exports.DEFAULT_CONFIG_ENV];
+    if (envPath && envPath.trim().length > 0) {
+        return expandHome(envPath.trim());
+    }
+    const xdgConfigHome = env.XDG_CONFIG_HOME;
+    const base = xdgConfigHome && xdgConfigHome.trim().length > 0
+        ? xdgConfigHome.trim()
+        : node_path_1.default.join(node_os_1.default.homedir(), '.config');
+    return node_path_1.default.join(base, 'gh-pulse', 'config.yaml');
+}
+function resolveCachePath(configuredPath, env = process.env) {
+    if (configuredPath && configuredPath.trim().length > 0) {
+        return expandHome(configuredPath.trim());
+    }
+    const xdgCacheHome = env.XDG_CACHE_HOME;
+    const base = xdgCacheHome && xdgCacheHome.trim().length > 0
+        ? xdgCacheHome.trim()
+        : node_path_1.default.join(node_os_1.default.homedir(), '.cache');
+    return node_path_1.default.join(base, 'gh-pulse', 'cache.db');
+}
+async function loadConfig(options = {}) {
+    const env = options.env ?? process.env;
+    const configPath = resolveConfigPath(options.path, env);
+    const rawText = await node_fs_1.promises.readFile(configPath, 'utf8');
+    const parsed = yaml_1.default.parse(rawText) ?? {};
+    // Resolve env placeholders, allowing GITHUB_TOKEN to be missing
+    const resolved = resolveEnvPlaceholders(parsed, env, ['GITHUB_TOKEN']);
+    const parsedConfig = ConfigSchema.parse(resolved);
+    // Resolve GitHub token: config > env > gh CLI
+    let githubToken = parsedConfig.github_token;
+    if (!githubToken || githubToken.trim().length === 0) {
+        // Try gh CLI as fallback
+        githubToken = getGhCliToken();
+    }
+    if (!githubToken || githubToken.trim().length === 0) {
+        throw new Error('GitHub token not found. Provide github_token in config, set GITHUB_TOKEN env var, or authenticate with `gh auth login`');
+    }
+    const timezone = parsedConfig.timezone.trim().length > 0
+        ? parsedConfig.timezone
+        : Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    return ResolvedConfigSchema.parse({
+        ...parsedConfig,
+        github_token: githubToken,
+        timezone,
+        cache: {
+            ...parsedConfig.cache,
+            path: resolveCachePath(parsedConfig.cache.path, env),
+        },
+    });
+}
+function resolveEnvPlaceholders(value, env, allowMissing = []) {
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveEnvPlaceholders(item, env, allowMissing));
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value);
+        return Object.fromEntries(entries.map(([key, val]) => [key, resolveEnvPlaceholders(val, env, allowMissing)]));
+    }
+    if (typeof value === 'string') {
+        return substituteEnv(value, env, allowMissing);
+    }
+    return value;
+}
+function substituteEnv(value, env, allowMissing = []) {
+    return value.replace(/\$\{([A-Z0-9_]+)\}/gi, (_, name) => {
+        const replacement = env[name];
+        if (!replacement || replacement.trim().length === 0) {
+            if (allowMissing.includes(name)) {
+                return ''; // Return empty string, will be handled by fallback logic
+            }
+            throw new Error(`Missing environment variable for ${name}`);
+        }
+        return replacement;
+    });
+}
+function expandHome(value) {
+    if (!value.startsWith('~')) {
+        return value;
+    }
+    return node_path_1.default.join(node_os_1.default.homedir(), value.slice(1));
+}
+exports.CONFIG_SCHEMA = ConfigSchema;