@0xbigboss/gh-pulse-core 1.0.0

package/dist/cache.cjs

@@ -0,0 +1,312 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+exports.getEventTimestamp = getEventTimestamp;
+exports.toCommitFromEvent = toCommitFromEvent;
+const bun_sqlite_1 = require("bun:sqlite");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+class Cache {
+    db;
+    now;
+    constructor(db, now) {
+        this.db = db;
+        this.now = now;
+    }
+    static async open(options) {
+        await ensureDir(options.path);
+        const db = new bun_sqlite_1.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}`);
+            }
+        }
+    }
+}
+exports.Cache = Cache;
+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 = node_path_1.default.dirname(dbPath);
+    await node_fs_1.promises.mkdir(dir, { recursive: true });
+}
+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/cache.d.cts

@@ -0,0 +1,58 @@
+import type { Commit, CommitPushedEvent, Event, GitHubUsername, PullRequest, RepoFullName, Timestamp } from "./types.cjs";
+export interface CacheFreshness {
+    dataAsOf: Timestamp | null;
+    cacheAgeMinutes: number | null;
+    reposSynced: number;
+    totalRepos: number;
+}
+export interface CacheOptions {
+    path: string;
+    now?: () => number;
+}
+export interface SyncState {
+    repo: RepoFullName;
+    last_sync: Timestamp;
+    cursor: string | null;
+}
+export declare class Cache {
+    private readonly db;
+    private readonly now;
+    private constructor();
+    static open(options: CacheOptions): Promise<Cache>;
+    init(): void;
+    close(): void;
+    insertEvent(event: Event, fetchedAt?: Timestamp): boolean;
+    upsertPullRequest(pr: PullRequest, fetchedAt?: Timestamp): void;
+    upsertCommit(commit: Commit, fetchedAt?: Timestamp): void;
+    getPullRequest(repo: RepoFullName, number: number): {
+        data: PullRequest;
+        fetched_at: Timestamp;
+    } | null;
+    getPullRequests(filter?: {
+        repo?: RepoFullName;
+        author?: GitHubUsername;
+        state?: string;
+    }): PullRequest[];
+    getCommits(filter?: {
+        repo?: RepoFullName;
+        author?: GitHubUsername;
+    }): Commit[];
+    getCommit(repo: RepoFullName, sha: string): {
+        data: Commit;
+        fetched_at: Timestamp;
+    } | null;
+    getEvents(filter?: {
+        repo?: RepoFullName;
+        type?: Event['type'];
+        since?: Timestamp;
+        until?: Timestamp;
+    }): Event[];
+    getEventsForPr(repo: RepoFullName, prNumber: number): Event[];
+    getSyncState(repo: RepoFullName): SyncState | null;
+    upsertSyncState(repo: RepoFullName, lastSync: Timestamp, cursor?: string | null): void;
+    getFreshness(repos: RepoFullName[]): CacheFreshness;
+    isFresh(fetchedAt: Timestamp, ttlHours: number): boolean;
+    private eventExists;
+}
+export declare function getEventTimestamp(event: Event): Timestamp;
+export declare function toCommitFromEvent(event: CommitPushedEvent): Commit;

package/dist/cache.d.ts

@@ -0,0 +1,58 @@
+import type { Commit, CommitPushedEvent, Event, GitHubUsername, PullRequest, RepoFullName, Timestamp } from "./types.js";
+export interface CacheFreshness {
+    dataAsOf: Timestamp | null;
+    cacheAgeMinutes: number | null;
+    reposSynced: number;
+    totalRepos: number;
+}
+export interface CacheOptions {
+    path: string;
+    now?: () => number;
+}
+export interface SyncState {
+    repo: RepoFullName;
+    last_sync: Timestamp;
+    cursor: string | null;
+}
+export declare class Cache {
+    private readonly db;
+    private readonly now;
+    private constructor();
+    static open(options: CacheOptions): Promise<Cache>;
+    init(): void;
+    close(): void;
+    insertEvent(event: Event, fetchedAt?: Timestamp): boolean;
+    upsertPullRequest(pr: PullRequest, fetchedAt?: Timestamp): void;
+    upsertCommit(commit: Commit, fetchedAt?: Timestamp): void;
+    getPullRequest(repo: RepoFullName, number: number): {
+        data: PullRequest;
+        fetched_at: Timestamp;
+    } | null;
+    getPullRequests(filter?: {
+        repo?: RepoFullName;
+        author?: GitHubUsername;
+        state?: string;
+    }): PullRequest[];
+    getCommits(filter?: {
+        repo?: RepoFullName;
+        author?: GitHubUsername;
+    }): Commit[];
+    getCommit(repo: RepoFullName, sha: string): {
+        data: Commit;
+        fetched_at: Timestamp;
+    } | null;
+    getEvents(filter?: {
+        repo?: RepoFullName;
+        type?: Event['type'];
+        since?: Timestamp;
+        until?: Timestamp;
+    }): Event[];
+    getEventsForPr(repo: RepoFullName, prNumber: number): Event[];
+    getSyncState(repo: RepoFullName): SyncState | null;
+    upsertSyncState(repo: RepoFullName, lastSync: Timestamp, cursor?: string | null): void;
+    getFreshness(repos: RepoFullName[]): CacheFreshness;
+    isFresh(fetchedAt: Timestamp, ttlHours: number): boolean;
+    private eventExists;
+}
+export declare function getEventTimestamp(event: Event): Timestamp;
+export declare function toCommitFromEvent(event: CommitPushedEvent): Commit;