relay-ide 0.1.0

package/dist/server/gh.js

@@ -0,0 +1,276 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createLogger } from './logger.js';
+const execFileAsync = promisify(execFile);
+const logger = createLogger('gh');
+// ── PR lookup cache ─────────────────────────────────────────────────────────
+// Caches `getPrForBranch` results to avoid spawning a `gh` subprocess on every
+// request. Negative results (no PR) use a longer TTL since they only change on
+// user action (push, PR creation).
+const PR_CACHE_POSITIVE_TTL_MS = 60_000; // 60s — same as org-dashboard
+const PR_CACHE_NEGATIVE_TTL_MS = 300_000; // 5 min — "no PR" rarely changes without user action
+const prCache = new Map();
+function prCacheKey(repoPath, branch) {
+    return `${repoPath}:${branch}`;
+}
+function getPrCached(repoPath, branch) {
+    const key = prCacheKey(repoPath, branch);
+    const entry = prCache.get(key);
+    if (!entry)
+        return undefined;
+    const ttl = entry.result
+        ? PR_CACHE_POSITIVE_TTL_MS
+        : PR_CACHE_NEGATIVE_TTL_MS;
+    if (Date.now() - entry.fetchedAt > ttl) {
+        prCache.delete(key);
+        return undefined;
+    }
+    return entry;
+}
+function setPrCached(repoPath, branch, result) {
+    prCache.set(prCacheKey(repoPath, branch), { result, fetchedAt: Date.now() });
+}
+/** Clear PR cache entries. If repoPath is given, only clears entries for that repo. */
+function clearPrCache(repoPath) {
+    if (!repoPath) {
+        prCache.clear();
+        return;
+    }
+    const prefix = `${repoPath}:`;
+    for (const key of prCache.keys()) {
+        if (key.startsWith(prefix))
+            prCache.delete(key);
+    }
+}
+async function getCiStatus(repoPath, branch, options = {}) {
+    const run = options.exec || execFileAsync;
+    let stdout;
+    let stderr;
+    try {
+        ({ stdout, stderr } = await run('gh', ['pr', 'checks', branch, '--json', 'name,state,conclusion'], { cwd: repoPath, timeout: 5000 }));
+    }
+    catch (err) {
+        if (err && typeof err === 'object') {
+            const errObj = err;
+            const errorText = errObj.stderr ?? errObj.message ?? '';
+            // gh not installed
+            if (errObj.code === 'ENOENT')
+                return null;
+            // Not authenticated
+            if (typeof errorText === 'string' &&
+                (errorText.includes('not logged into') ||
+                    errorText.includes('authentication'))) {
+                return {
+                    total: 0,
+                    passing: 0,
+                    failing: 0,
+                    pending: 0,
+                    authError: true,
+                };
+            }
+            // No PR for branch
+            if (typeof errorText === 'string' &&
+                (errorText.includes('no pull requests found') ||
+                    errorText.includes('Could not find'))) {
+                return null;
+            }
+        }
+        return null;
+    }
+    // gh may exit 0 but write errors or auth prompts to stderr
+    if (stderr &&
+        (stderr.includes('not logged into') || stderr.includes('authentication'))) {
+        return { total: 0, passing: 0, failing: 0, pending: 0, authError: true };
+    }
+    if (!stdout.trim())
+        return null;
+    try {
+        const checks = JSON.parse(stdout);
+        let passing = 0;
+        let failing = 0;
+        let pending = 0;
+        for (const check of checks) {
+            const conclusion = (check.conclusion ?? '').toUpperCase();
+            const state = (check.state ?? '').toUpperCase();
+            if (conclusion === 'SUCCESS' ||
+                conclusion === 'SKIPPED' ||
+                conclusion === 'NEUTRAL') {
+                passing++;
+            }
+            else if (conclusion === 'FAILURE' ||
+                conclusion === 'CANCELLED' ||
+                conclusion === 'TIMED_OUT') {
+                failing++;
+            }
+            else if (state === 'IN_PROGRESS' ||
+                state === 'QUEUED' ||
+                state === 'PENDING' ||
+                conclusion === '') {
+                pending++;
+            }
+            else {
+                // Unknown conclusion — treat as pending rather than silently ignoring
+                pending++;
+            }
+        }
+        return { total: checks.length, passing, failing, pending };
+    }
+    catch {
+        return null;
+    }
+}
+async function getPrForBranch(repoPath, branch, options = {}) {
+    const run = options.exec || execFileAsync;
+    let stdout;
+    try {
+        ({ stdout } = await run('gh', [
+            'pr',
+            'view',
+            branch,
+            '--json',
+            'number,title,url,state,headRefName,baseRefName,reviewDecision,isDraft,additions,deletions,mergeable,updatedAt',
+        ], { cwd: repoPath, timeout: 5000 }));
+    }
+    catch {
+        return null;
+    }
+    if (!stdout.trim())
+        return null;
+    try {
+        const data = JSON.parse(stdout);
+        return {
+            number: data.number,
+            title: data.title,
+            url: data.url,
+            state: data.state,
+            headRefName: data.headRefName,
+            baseRefName: data.baseRefName,
+            isDraft: data.isDraft,
+            reviewDecision: data.reviewDecision ?? null,
+            additions: data.additions ?? 0,
+            deletions: data.deletions ?? 0,
+            mergeable: data.mergeable ?? 'UNKNOWN',
+            unresolvedCommentCount: 0,
+            updatedAt: data.updatedAt ?? '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Batch-fetch all PRs for a repo in a single `gh pr list` call.
+ * Returns a Map of headRefName → PrInfo for quick branch lookup.
+ * Includes both open and closed/merged PRs (up to 100 most recent).
+ */
+async function batchGetPrsForRepo(repoPath, options = {}) {
+    const run = options.exec || execFileAsync;
+    const prMap = new Map();
+    try {
+        const { stdout } = await run('gh', [
+            'pr',
+            'list',
+            '--state',
+            'all',
+            '--limit',
+            '100',
+            '--json',
+            'number,title,url,state,headRefName,baseRefName,reviewDecision,isDraft,additions,deletions,mergeable,updatedAt',
+        ], { cwd: repoPath, timeout: 10000 });
+        if (!stdout.trim())
+            return prMap;
+        const prs = JSON.parse(stdout);
+        for (const data of prs) {
+            prMap.set(data.headRefName, {
+                number: data.number,
+                title: data.title,
+                url: data.url,
+                state: data.state,
+                headRefName: data.headRefName,
+                baseRefName: data.baseRefName,
+                isDraft: data.isDraft,
+                reviewDecision: data.reviewDecision ?? null,
+                additions: data.additions ?? 0,
+                deletions: data.deletions ?? 0,
+                mergeable: data.mergeable ?? 'UNKNOWN',
+                unresolvedCommentCount: 0,
+                updatedAt: data.updatedAt ?? '',
+            });
+        }
+    }
+    catch (err) {
+        logger.warn('[gh] batchGetPrsForRepo failed for', repoPath, err instanceof Error ? err.message : err);
+    }
+    return prMap;
+}
+async function getUnresolvedCommentCount(repoPath, prNumber, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        const { stdout: repoStdout } = await run('gh', ['repo', 'view', '--json', 'nameWithOwner', '--jq', '.nameWithOwner'], { cwd: repoPath, timeout: 5000 });
+        const nameWithOwner = repoStdout.trim();
+        if (!nameWithOwner)
+            return 0;
+        const [owner, repo] = nameWithOwner.split('/');
+        if (!owner || !repo)
+            return 0;
+        const query = `query($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100) {
+        nodes { isResolved }
+      }
+    }
+  }
+}`;
+        const { stdout } = await run('gh', [
+            'api',
+            'graphql',
+            '-f',
+            `query=${query}`,
+            '-f',
+            `owner=${owner}`,
+            '-f',
+            `repo=${repo}`,
+            '-F',
+            `number=${prNumber}`,
+        ], { cwd: repoPath, timeout: 10000 });
+        const result = JSON.parse(stdout);
+        const nodes = result?.data?.repository?.pullRequest?.reviewThreads?.nodes ?? [];
+        return nodes.filter((n) => !n.isResolved).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function changePrBase(repoPath, prNumber, baseBranch, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        await run('gh', ['pr', 'edit', String(prNumber), '--base', baseBranch], {
+            cwd: repoPath,
+            timeout: 10000,
+        });
+        return { success: true };
+    }
+    catch (err) {
+        const errObj = err;
+        if (errObj.code === 'ENOENT')
+            return { success: false, error: 'gh CLI not installed' };
+        return {
+            success: false,
+            error: (errObj.stderr ?? errObj.message ?? 'Unknown error').trim(),
+        };
+    }
+}
+const ONE_DAY_MS = 86_400_000;
+/** A PR is stale if it's MERGED or CLOSED and was last updated more than 1 day ago (or has no valid timestamp). */
+function isStalePr(pr) {
+    if (pr.state === 'OPEN')
+        return false;
+    if (!pr.updatedAt)
+        return true; // no timestamp → treat as stale
+    const elapsed = Date.now() - new Date(pr.updatedAt).getTime();
+    if (Number.isNaN(elapsed))
+        return true; // unparseable date → treat as stale
+    return elapsed > ONE_DAY_MS;
+}
+export { getCiStatus, getPrForBranch, batchGetPrsForRepo, getUnresolvedCommentCount, changePrBase, isStalePr, getPrCached, setPrCached, clearPrCache, };

package/dist/server/git-routes.js

@@ -0,0 +1,154 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Router } from 'express';
+import { listBranchesEnriched } from './git.js';
+import { readMeta } from './config.js';
+import { WORKTREE_DIRS, parseWorktreeListPorcelain } from './watcher.js';
+const execFileAsync = promisify(execFile);
+export async function scanWorktrees(deps, repoParam) {
+    const config = deps.getConfig();
+    const roots = config.rootDirs || [];
+    const worktrees = [];
+    let reposToScan;
+    if (repoParam) {
+        const root = roots.find((r) => repoParam.startsWith(r)) || '';
+        reposToScan = [
+            {
+                path: repoParam,
+                name: repoParam.split('/').filter(Boolean).pop() || '',
+                root,
+            },
+        ];
+    }
+    else {
+        reposToScan = [];
+        for (const rootDir of roots) {
+            let entries;
+            try {
+                entries = deps.readdirSync(rootDir);
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.'))
+                    continue;
+                const fullPath = path.join(rootDir, entry.name);
+                const dotGit = path.join(fullPath, '.git');
+                try {
+                    if (deps.statSync(dotGit).isDirectory()) {
+                        reposToScan.push({
+                            name: entry.name,
+                            path: fullPath,
+                            root: rootDir,
+                        });
+                    }
+                }
+                catch {
+                    // .git doesn't exist — not a repo
+                }
+            }
+        }
+        // Also include directly-configured repos (may not be under any rootDir)
+        const configRepos = config.repos ?? [];
+        const scannedPaths = new Set(reposToScan.map((r) => r.path));
+        for (const wp of configRepos) {
+            if (scannedPaths.has(wp))
+                continue;
+            const root = roots.find((r) => wp.startsWith(r)) || '';
+            reposToScan.push({
+                path: wp,
+                name: wp.split('/').filter(Boolean).pop() || '',
+                root,
+            });
+        }
+    }
+    for (const repo of reposToScan) {
+        try {
+            const { stdout } = await deps.execFileAsync('git', ['worktree', 'list', '--porcelain'], { cwd: repo.path });
+            const parsed = parseWorktreeListPorcelain(stdout, repo.path);
+            for (const wt of parsed) {
+                const dirName = wt.path.split('/').pop() || '';
+                const meta = deps.readMeta(deps.configPath, wt.path);
+                worktrees.push({
+                    name: dirName,
+                    path: wt.path,
+                    repoName: repo.name,
+                    repoPath: repo.path,
+                    root: repo.root,
+                    displayName: meta?.displayName || wt.branch || dirName,
+                    lastActivity: meta?.lastActivity || '',
+                    branchName: wt.branch || meta?.branchName || dirName,
+                });
+            }
+        }
+        catch {
+            // git worktree list failed — fall back to directory scanning
+            for (const dir of WORKTREE_DIRS) {
+                const worktreeDir = path.join(repo.path, dir);
+                let entries;
+                try {
+                    entries = deps.readdirSync(worktreeDir);
+                }
+                catch {
+                    continue;
+                }
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const wtPath = path.join(worktreeDir, entry.name);
+                    const meta = deps.readMeta(deps.configPath, wtPath);
+                    worktrees.push({
+                        name: entry.name,
+                        path: wtPath,
+                        repoName: repo.name,
+                        repoPath: repo.path,
+                        root: repo.root,
+                        displayName: meta?.displayName || '',
+                        lastActivity: meta?.lastActivity || '',
+                        branchName: meta?.branchName || entry.name,
+                    });
+                }
+            }
+        }
+    }
+    // Deduplicate by path
+    const seen = new Set();
+    return worktrees.filter((wt) => {
+        if (seen.has(wt.path))
+            return false;
+        seen.add(wt.path);
+        return true;
+    });
+}
+export function createGitRouter(deps) {
+    const router = Router();
+    const routerDeps = {
+        getConfig: deps.getConfig,
+        configPath: deps.configPath,
+        execFileAsync: execFileAsync,
+        readdirSync: (dir) => fs.readdirSync(dir, { withFileTypes: true }),
+        statSync: (p) => fs.statSync(p),
+        readMeta: (configPath, worktreePath) => readMeta(configPath, worktreePath),
+    };
+    // GET /git/worktrees — pure git worktree list, no enrichment
+    router.get('/worktrees', async (req, res) => {
+        const repoParam = typeof req.query.repo === 'string' ? req.query.repo : undefined;
+        const items = await scanWorktrees(routerDeps, repoParam);
+        res.json(items);
+    });
+    // GET /git/branches — branch list with local-only data
+    router.get('/branches', async (req, res) => {
+        const repoPath = typeof req.query.repo === 'string' ? req.query.repo : undefined;
+        const refresh = req.query.refresh === '1';
+        if (!repoPath) {
+            res.status(400).json({ error: 'repo query parameter is required' });
+            return;
+        }
+        const sessionList = deps.getSessions();
+        res.json(await listBranchesEnriched(repoPath, { refresh, sessions: sessionList }));
+    });
+    return router;
+}