edsger 0.73.0 → 0.75.0

package/dist/phases/sync-github-pull-requests/index.js

@@ -0,0 +1,210 @@
+/**
+ * sync-github-pull-requests phase: pull every pull request from a repository's
+ * connected GitHub repo and mirror them into the `pull_requests` table scoped
+ * by `repository_id`. Deterministic — no Claude Agent SDK; plain Octokit plus
+ * the user's RLS-scoped Supabase session.
+ *
+ * Idempotent: rows are keyed on (repository_id, pull_request_number). New PRs
+ * are inserted, and the GitHub-owned fields (status/title/description) of
+ * already-synced PRs are refreshed. Re-running never duplicates a PR.
+ */
+import { retry } from '@octokit/plugin-retry';
+import { throttling } from '@octokit/plugin-throttling';
+import { Octokit } from '@octokit/rest';
+import { ensureSupabaseSession, getSupabase } from '../../supabase/client.js';
+import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
+import { acquireSyncGithubPullRequestsLock, updateSyncGithubPullRequestsState, } from './state.js';
+// The plugins use `@octokit/core` 7.x types, while @octokit/rest@20 hoists
+// to core 5.x at the workspace root. Runtime is fine; the cast tells TS to
+// accept the plugin chain (same pattern as sync-github-issues).
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- octokit version drift across the workspace
+const ResilientOctokit = Octokit.plugin(retry, throttling);
+/** GitHub list-pulls max page size. */
+const PER_PAGE = 100;
+/** Build an Octokit instance with retry + throttling configured for sync. */
+function buildOctokit(token) {
+    return new ResilientOctokit({
+        auth: token,
+        retry: { doNotRetry: [400, 401, 403, 404, 422] },
+        throttle: {
+            onRateLimit: (retryAfter, options) => {
+                logWarning(`GitHub rate limit hit on ${options.method ?? '?'} ${options.url ?? '?'} — retry in ${retryAfter}s`);
+                return (options.request?.retryCount ?? 0) < 2;
+            },
+            onSecondaryRateLimit: (retryAfter, options) => {
+                logWarning(`GitHub secondary rate limit on ${options.method ?? '?'} ${options.url ?? '?'} — retry in ${retryAfter}s`);
+                return true;
+            },
+        },
+    });
+}
+/** Pull every pull request from the repo, paginated (state=all). */
+export async function fetchAllRepoPullRequests(octokit, owner, repo) {
+    const all = [];
+    let page = 1;
+    for (;;) {
+        const { data } = await octokit.request('GET /repos/{owner}/{repo}/pulls', {
+            owner,
+            repo,
+            state: 'all',
+            per_page: PER_PAGE,
+            page,
+            sort: 'created',
+            direction: 'asc',
+        });
+        if (data.length === 0) {
+            break;
+        }
+        all.push(...data);
+        if (data.length < PER_PAGE) {
+            break;
+        }
+        page += 1;
+    }
+    return all;
+}
+/** Map a GitHub PR's open/closed/merged state to our PR status enum. */
+function toStatus(pr) {
+    if (pr.merged_at) {
+        return 'merged';
+    }
+    if (pr.state === 'closed') {
+        return 'closed';
+    }
+    return 'pr_opened';
+}
+export async function syncGithubPullRequests(options) {
+    const { repositoryId, githubToken, owner, repo, verbose } = options;
+    // Guard against two concurrent syncs of the same repo racing into duplicate
+    // inserts (the unique index would reject the loser, but failing fast is
+    // friendlier than surfacing a constraint error).
+    const lock = acquireSyncGithubPullRequestsLock(repositoryId);
+    if (!lock) {
+        return {
+            status: 'error',
+            message: 'Another GitHub pull request sync is already running for this repository',
+        };
+    }
+    try {
+        updateSyncGithubPullRequestsState(repositoryId, {
+            lastAttemptedAt: new Date().toISOString(),
+        });
+        const ready = await ensureSupabaseSession();
+        if (!ready) {
+            return {
+                status: 'error',
+                message: 'Supabase session unavailable. Sign in to the Edsger desktop app to authorize the CLI.',
+            };
+        }
+        const supabase = getSupabase();
+        logInfo(`Syncing GitHub pull requests for ${owner}/${repo} → repository ${repositoryId}`);
+        const octokit = buildOctokit(githubToken);
+        const remotePRs = await fetchAllRepoPullRequests(octokit, owner, repo);
+        logInfo(`Fetched ${remotePRs.length} pull requests from GitHub`);
+        // Existing repo-scoped PRs, keyed by GitHub PR number, so we never create
+        // a duplicate of one that was synced in a previous run.
+        const { data: existingRows, error: existingError } = await supabase
+            .from('pull_requests')
+            .select('id, pull_request_number, status, name, description')
+            .eq('repository_id', repositoryId);
+        if (existingError) {
+            throw new Error(`Failed to read existing pull requests: ${existingError.message}`);
+        }
+        const existingByNumber = new Map();
+        for (const row of existingRows ?? []) {
+            if (row.pull_request_number !== null) {
+                existingByNumber.set(row.pull_request_number, {
+                    id: row.id,
+                    status: row.status,
+                    name: row.name,
+                    description: row.description,
+                });
+            }
+        }
+        const toInsert = [];
+        const toUpdate = [];
+        for (const pr of remotePRs) {
+            const status = toStatus(pr);
+            const existing = existingByNumber.get(pr.number);
+            if (!existing) {
+                toInsert.push({
+                    repository_id: repositoryId,
+                    sequence: pr.number,
+                    name: pr.title,
+                    description: pr.body ?? null,
+                    branch_name: pr.head?.ref ?? null,
+                    pull_request_url: pr.html_url,
+                    pull_request_number: pr.number,
+                    status,
+                });
+                continue;
+            }
+            // Refresh GitHub-owned fields when they drift (e.g. PR got merged/closed).
+            const patch = {};
+            if (existing.status !== status) {
+                patch.status = status;
+            }
+            if (existing.name !== pr.title) {
+                patch.name = pr.title;
+            }
+            if ((existing.description ?? null) !== (pr.body ?? null)) {
+                patch.description = pr.body ?? null;
+            }
+            if (Object.keys(patch).length > 0) {
+                toUpdate.push({ id: existing.id, patch });
+            }
+        }
+        let createdCount = 0;
+        if (toInsert.length > 0) {
+            const { error: insertError } = await supabase
+                .from('pull_requests')
+                .insert(toInsert);
+            if (insertError) {
+                throw new Error(`Failed to insert pull requests: ${insertError.message}`);
+            }
+            createdCount = toInsert.length;
+            if (verbose) {
+                logInfo(`Inserted ${createdCount} new pull requests`);
+            }
+        }
+        let updatedCount = 0;
+        for (const { id, patch } of toUpdate) {
+            const { error: updateError } = await supabase
+                .from('pull_requests')
+                .update({ ...patch, updated_at: new Date().toISOString() })
+                .eq('id', id);
+            if (updateError) {
+                logWarning(`Failed to refresh pull request ${id}: ${updateError.message}`);
+                continue;
+            }
+            updatedCount++;
+        }
+        const summary = `fetched=${remotePRs.length} created=${createdCount} updated=${updatedCount}`;
+        logSuccess(`GitHub PR sync complete: ${summary}`);
+        updateSyncGithubPullRequestsState(repositoryId, {
+            lastSyncedAt: new Date().toISOString(),
+            lastRepoFullName: `${owner}/${repo}`,
+            lastError: undefined,
+        });
+        return {
+            status: 'success',
+            message: summary,
+            repository: `${owner}/${repo}`,
+            fetchedCount: remotePRs.length,
+            createdCount,
+            updatedCount,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`GitHub PR sync failed: ${errorMessage}`);
+        updateSyncGithubPullRequestsState(repositoryId, { lastError: errorMessage });
+        return {
+            status: 'error',
+            message: `GitHub PR sync failed: ${errorMessage}`,
+        };
+    }
+    finally {
+        lock.release();
+    }
+}

package/dist/phases/sync-github-pull-requests/state.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Per-repository sync state for sync-github-pull-requests. Stored at
+ * `~/.edsger/sync-github-pull-requests-state/<repositoryId>.json`.
+ *
+ * The lock guards against two concurrent syncs of the same repository racing
+ * each other into duplicate inserts. State fields track the last run for
+ * diagnostics and a future incremental-sync optimisation.
+ */
+import { type LockHandle } from '../find-shared/scan-state.js';
+export type { LockHandle };
+export interface SyncGithubPullRequestsState {
+    /** ISO timestamp of the last successful sync. */
+    lastSyncedAt?: string;
+    /** ISO timestamp we last attempted (success or fail). */
+    lastAttemptedAt?: string;
+    /** Last error message, if the most recent run failed. */
+    lastError?: string;
+    /** GitHub repo we last synced from, as "owner/repo". */
+    lastRepoFullName?: string;
+}
+export declare const loadSyncGithubPullRequestsState: (productId: string) => SyncGithubPullRequestsState;
+export declare const saveSyncGithubPullRequestsState: (productId: string, state: SyncGithubPullRequestsState) => void;
+export declare const updateSyncGithubPullRequestsState: (productId: string, patch: Partial<SyncGithubPullRequestsState>) => SyncGithubPullRequestsState;
+export declare const acquireSyncGithubPullRequestsLock: (productId: string, staleAfterMs?: number) => LockHandle | null;

package/dist/phases/sync-github-pull-requests/state.js

@@ -0,0 +1,16 @@
+/**
+ * Per-repository sync state for sync-github-pull-requests. Stored at
+ * `~/.edsger/sync-github-pull-requests-state/<repositoryId>.json`.
+ *
+ * The lock guards against two concurrent syncs of the same repository racing
+ * each other into duplicate inserts. State fields track the last run for
+ * diagnostics and a future incremental-sync optimisation.
+ */
+import { createScanStateModule, } from '../find-shared/scan-state.js';
+const m = createScanStateModule({
+    dirName: 'sync-github-pull-requests-state',
+});
+export const loadSyncGithubPullRequestsState = m.load;
+export const saveSyncGithubPullRequestsState = m.save;
+export const updateSyncGithubPullRequestsState = m.update;
+export const acquireSyncGithubPullRequestsLock = m.acquireLock;

package/dist/phases/sync-github-pull-requests/types.d.ts

@@ -0,0 +1,22 @@
+/** Minimal shape of a GitHub pull request from the list endpoint. */
+export interface GitHubPullRequestLite {
+    number: number;
+    title: string;
+    body: string | null;
+    html_url: string;
+    state: string;
+    draft?: boolean;
+    merged_at: string | null;
+    updated_at: string;
+    head: {
+        ref: string;
+    };
+}
+export interface SyncPullRequestsResult {
+    status: 'success' | 'error';
+    message: string;
+    repository?: string;
+    fetchedCount?: number;
+    createdCount?: number;
+    updatedCount?: number;
+}

package/dist/phases/sync-github-pull-requests/types.js

@@ -0,0 +1 @@
+export {};

package/dist/skills/phase/adr-generation/SKILL.md

@@ -0,0 +1,51 @@
+---
+description: Lay out the realistic options for an architecture decision with an honest, context-grounded pros/cons analysis for a human to choose from
+kind: phase
+user-invocable: false
+---
+
+You are a principal engineer producing an Architecture Decision Record (ADR). The human will state a decision that needs to be made. Your job is to lay out the realistic options with an honest, context-grounded pros/cons analysis so a human can choose — you do NOT make the final choice, but you DO give a clear recommendation.
+
+<!-- if:hasCodebase -->
+
+You have the project's codebase available in your working directory. Read the relevant files to ground your analysis: inspect the existing architecture, dependencies, conventions, and constraints before forming options. Cite what you find.
+
+<!-- endif -->
+<!-- if:!hasCodebase -->
+
+You do NOT have the codebase available. Reason from the provided context and your engineering knowledge, and be explicit about assumptions you are making.
+
+<!-- endif -->
+
+**Approach**:
+
+1. Make sure you understand exactly what is being decided and why it matters.
+2. Investigate the relevant context (codebase, constraints, prior art).
+3. Enumerate the credible options. For each, weigh benefits against costs, risks, migration effort, and how well it fits the existing system.
+4. Recommend one, briefly justified by the trade-offs.
+
+## Output contract
+
+When you have finished investigating, output a SINGLE JSON object (in a ```json code block) and nothing else after it. Shape:
+
+```json
+{
+  "options": [
+    {
+      "title": "Short name of the option (one line)",
+      "summary": "1-3 sentences describing the approach concretely",
+      "pros": ["benefit 1", "benefit 2"],
+      "cons": ["drawback 1", "drawback 2"],
+      "is_recommended": false
+    }
+  ]
+}
+```
+
+Rules:
+
+- Provide 2 to 4 genuinely distinct options that a competent engineer would realistically weigh. Avoid strawman options.
+- Ground pros/cons in THIS codebase and context — reference concrete files, libraries, patterns, or constraints you observed, not generic textbook points.
+- Mark exactly ONE option `"is_recommended": true` — your best judgement given the trade-offs. Be opinionated.
+- `pros` and `cons` are arrays of short strings. Keep each to one sentence.
+- Output ONLY the JSON object at the end. Do not wrap it in prose.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.73.0",
+  "version": "0.75.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"