relay-ide 0.1.0

package/dist/server/config.js

@@ -0,0 +1,325 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { createLogger } from './logger.js';
+const logger = createLogger('config');
+export const DEFAULT_PRESETS = [
+    {
+        name: 'Needs Attention',
+        builtIn: true,
+        filters: {},
+        sort: { column: 'role', direction: 'asc' },
+    },
+    {
+        name: 'All PRs',
+        builtIn: true,
+        filters: {},
+        sort: { column: 'age', direction: 'desc' },
+    },
+];
+export const DEFAULTS = {
+    host: '0.0.0.0',
+    port: 3456,
+    cookieTTL: '24h',
+    repos: [],
+    claudeCommand: 'claude',
+    claudeArgs: [],
+    defaultAgent: 'claude',
+    defaultFramework: 'claude',
+    defaultContinue: true,
+    defaultYolo: false,
+    launchInTmux: false,
+    defaultNotifications: true,
+    updateChannel: 'stable',
+};
+function migrateToV4(config, configPath) {
+    if (config.configVersion != null && config.configVersion >= 4)
+        return;
+    // Step 1: Reconcile repo arrays
+    const legacyWorkspaces = config.workspaces;
+    const isLegacyStringArray = Array.isArray(legacyWorkspaces) &&
+        (legacyWorkspaces.length === 0 || typeof legacyWorkspaces[0] === 'string');
+    if (isLegacyStringArray && legacyWorkspaces.length > 0) {
+        if (!config.repos)
+            config.repos = [];
+        const repoSet = new Set(config.repos);
+        for (const w of legacyWorkspaces) {
+            if (!repoSet.has(w)) {
+                config.repos.push(w);
+                repoSet.add(w);
+            }
+        }
+    }
+    // Step 2: Rename workspaceSettings → repoSettings
+    if (config.workspaceSettings != null && config.repoSettings == null) {
+        config.repoSettings = config.workspaceSettings;
+        delete config.workspaceSettings;
+    }
+    // Step 3: Promote workspaceGroups → workspaces (Workspace[])
+    const promoted = [];
+    if (config.workspaceGroups != null) {
+        const validPaths = new Set(config.repos ?? []);
+        let order = 0;
+        for (const [groupName, paths] of Object.entries(config.workspaceGroups)) {
+            if (!Array.isArray(paths))
+                continue;
+            const validRepos = paths.filter((p) => validPaths.has(p));
+            if (validRepos.length > 0) {
+                promoted.push({
+                    id: crypto.randomUUID(),
+                    name: groupName,
+                    repos: validRepos,
+                    order: order++,
+                });
+            }
+        }
+        delete config.workspaceGroups;
+    }
+    // Set workspaces to promoted entities (or empty array if nothing was promoted)
+    config.workspaces = promoted;
+    // Step 4: Set version
+    config.configVersion = 4;
+    // Persist migrated config
+    saveConfig(configPath, config);
+}
+function migrateToV5(config, configPath) {
+    if (config.configVersion != null && config.configVersion >= 5)
+        return;
+    // Map defaultAgent → defaultFramework, preserving any explicit defaultFramework
+    if (config.defaultAgent && !config.defaultFramework) {
+        config.defaultFramework = config.defaultAgent;
+    }
+    // Map claudeCommand → frameworks.claude.commandOverride (only if non-default)
+    if (config.claudeCommand && config.claudeCommand !== 'claude') {
+        if (!config.frameworks)
+            config.frameworks = {};
+        if (!config.frameworks['claude'])
+            config.frameworks['claude'] = {};
+        if (!config.frameworks['claude'].commandOverride) {
+            config.frameworks['claude'].commandOverride = config.claudeCommand;
+        }
+    }
+    // Map claudeArgs → frameworks.claude.extraArgs (only if non-empty)
+    if (Array.isArray(config.claudeArgs) && config.claudeArgs.length > 0) {
+        if (!config.frameworks)
+            config.frameworks = {};
+        if (!config.frameworks['claude'])
+            config.frameworks['claude'] = {};
+        config.frameworks['claude'].extraArgs = config.claudeArgs;
+    }
+    // Migrate repoSettings: defaultAgent → defaultFramework per repo
+    if (config.repoSettings) {
+        for (const repoPath of Object.keys(config.repoSettings)) {
+            const repoSettings = config.repoSettings[repoPath];
+            if (repoSettings?.defaultAgent && !repoSettings.defaultFramework) {
+                repoSettings.defaultFramework = repoSettings.defaultAgent;
+            }
+        }
+    }
+    // Migrate workspace-level settings: defaultAgent → defaultFramework
+    if (config.workspaces) {
+        for (const workspace of config.workspaces) {
+            if (workspace.settings?.defaultAgent &&
+                !workspace.settings.defaultFramework) {
+                workspace.settings.defaultFramework = workspace.settings.defaultAgent;
+            }
+        }
+    }
+    config.configVersion = 5;
+    // Persist migrated config
+    saveConfig(configPath, config);
+}
+function migrateToV6(config, configPath) {
+    if (config.configVersion != null && config.configVersion >= 6)
+        return;
+    if (!config.updateChannel) {
+        config.updateChannel = 'stable';
+    }
+    config.configVersion = 6;
+    saveConfig(configPath, config);
+}
+export function loadConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    const config = { ...DEFAULTS, ...parsed };
+    // If defaultFramework was not explicitly set in the config file, derive it from defaultAgent
+    // so that legacy configs with only defaultAgent work correctly without migration
+    if (parsed.defaultFramework == null) {
+        config.defaultFramework = (parsed.defaultAgent ??
+            DEFAULTS.defaultAgent);
+    }
+    // Set default filter presets if not present in saved config (clone to avoid mutating the constant)
+    if (config.filterPresets == null) {
+        config.filterPresets = DEFAULT_PRESETS.map((p) => ({
+            ...p,
+            filters: { ...p.filters },
+            sort: { ...p.sort },
+        }));
+    }
+    // Validate and clean workspaceGroups
+    if (config.workspaceGroups != null) {
+        // Valid paths come from repos[] and legacy workspaces[] (string array, pre-v4)
+        const legacyWs = config.workspaces;
+        const legacyWsPaths = Array.isArray(legacyWs) &&
+            (legacyWs.length === 0 || typeof legacyWs[0] === 'string')
+            ? legacyWs
+            : [];
+        const validPaths = new Set([...(config.repos ?? []), ...legacyWsPaths]);
+        const cleaned = {};
+        for (const [groupName, paths] of Object.entries(config.workspaceGroups)) {
+            if (!Array.isArray(paths)) {
+                logger.warn(`workspaceGroups: group "${groupName}" value is not an array, skipping`);
+                continue;
+            }
+            const filteredPaths = [];
+            for (const p of paths) {
+                if (!validPaths.has(p)) {
+                    logger.warn(`workspaceGroups: path "${p}" in group "${groupName}" is not in repos[], skipping`);
+                    continue;
+                }
+                filteredPaths.push(p);
+            }
+            if (filteredPaths.length > 0) {
+                cleaned[groupName] = filteredPaths;
+            }
+        }
+        config.workspaceGroups = cleaned;
+    }
+    migrateToV4(config, configPath);
+    migrateToV5(config, configPath);
+    migrateToV6(config, configPath);
+    return config;
+}
+export function saveConfig(configPath, config) {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+export function getConfigDir(configPath) {
+    return path.dirname(configPath);
+}
+function metaDir(configPath) {
+    return path.join(getConfigDir(configPath), 'worktree-meta');
+}
+function metaFilePath(configPath, worktreePath) {
+    const hash = crypto
+        .createHash('sha256')
+        .update(worktreePath)
+        .digest('hex')
+        .slice(0, 16);
+    return path.join(metaDir(configPath), hash + '.json');
+}
+export function ensureMetaDir(configPath) {
+    const dir = metaDir(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+export function readMeta(configPath, worktreePath) {
+    const fp = metaFilePath(configPath, worktreePath);
+    try {
+        return JSON.parse(fs.readFileSync(fp, 'utf8'));
+    }
+    catch (_) {
+        return null;
+    }
+}
+export function writeMeta(configPath, meta) {
+    const fp = metaFilePath(configPath, meta.worktreePath);
+    ensureMetaDir(configPath);
+    fs.writeFileSync(fp, JSON.stringify(meta, null, 2), 'utf8');
+}
+export function deleteMeta(configPath, worktreePath) {
+    const fp = metaFilePath(configPath, worktreePath);
+    try {
+        fs.unlinkSync(fp);
+    }
+    catch (_) {
+        // File may not exist; ignore
+    }
+}
+export function getRepoSettings(config, repoPath) {
+    const globalDefaults = {
+        defaultAgent: config.defaultAgent,
+        defaultFramework: config.defaultFramework ?? config.defaultAgent,
+        defaultContinue: config.defaultContinue,
+        defaultYolo: config.defaultYolo,
+        launchInTmux: config.launchInTmux,
+        claudeArgs: config.claudeArgs,
+    };
+    const perWorkspace = config.repoSettings?.[repoPath] ??
+        config.workspaceSettings?.[repoPath] ??
+        {};
+    // Per-repo settings override global — only for defined keys
+    return { ...globalDefaults, ...perWorkspace };
+}
+export function resolveSessionSettings(config, repoPath, overrides, workspaceId) {
+    const globalDefaults = {
+        defaultAgent: config.defaultAgent,
+        defaultFramework: config.defaultFramework ?? config.defaultAgent,
+        defaultContinue: config.defaultContinue,
+        defaultYolo: config.defaultYolo,
+        launchInTmux: config.launchInTmux,
+        claudeArgs: config.claudeArgs,
+    };
+    let wsDefaults = {};
+    if (workspaceId) {
+        const workspace = config.workspaces?.find((w) => w.id === workspaceId);
+        if (workspace?.settings)
+            wsDefaults = workspace.settings;
+    }
+    const repoSpecific = config.repoSettings?.[repoPath] ?? {};
+    // Merge: repo overrides workspace overrides global
+    const merged = { ...globalDefaults, ...wsDefaults, ...repoSpecific };
+    // Map boolean defaultContinue → ContinuePolicy for backward compat
+    const configPolicy = merged.defaultContinuePolicy ??
+        (merged.defaultContinue ? 'always' : 'never');
+    // Resolve agent: prefer the most specific layer's defaultFramework, falling back to
+    // defaultAgent at that layer. This ensures workspace/repo defaultAgent still wins
+    // over a global defaultFramework.
+    const agentFromLayers = (() => {
+        // Repo layer (most specific)
+        if (repoSpecific.defaultFramework)
+            return repoSpecific.defaultFramework;
+        if (repoSpecific.defaultAgent)
+            return repoSpecific.defaultAgent;
+        // Workspace layer
+        if (wsDefaults.defaultFramework)
+            return wsDefaults.defaultFramework;
+        if (wsDefaults.defaultAgent)
+            return wsDefaults.defaultAgent;
+        // Global layer
+        return (globalDefaults.defaultFramework ??
+            globalDefaults.defaultAgent ??
+            'claude');
+    })();
+    return {
+        agent: overrides.agent ?? agentFromLayers,
+        yolo: overrides.yolo ?? merged.defaultYolo ?? false,
+        continuePolicy: overrides.continuePolicy ?? configPolicy,
+        useTmux: overrides.useTmux ?? merged.launchInTmux ?? false,
+        claudeArgs: overrides.claudeArgs ?? merged.claudeArgs ?? [],
+    };
+}
+export function deleteRepoSettingKeys(configPath, config, repoPath, keys) {
+    if (!config.repoSettings?.[repoPath])
+        return;
+    for (const key of keys) {
+        delete config.repoSettings[repoPath][key];
+    }
+    // Clean up empty repo setting entries
+    if (Object.keys(config.repoSettings[repoPath]).length === 0) {
+        delete config.repoSettings[repoPath];
+    }
+    saveConfig(configPath, config);
+}
+export function setRepoSettings(configPath, config, repoPath, settings) {
+    if (!config.repoSettings)
+        config.repoSettings = {};
+    config.repoSettings[repoPath] = {
+        ...config.repoSettings[repoPath],
+        ...settings,
+    };
+    saveConfig(configPath, config);
+}

package/dist/server/gh-routes.js

@@ -0,0 +1,163 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Router } from 'express';
+import { isBranchStale } from './git.js';
+import { batchGetPrsForRepo, getCiStatus, getPrForBranch, isStalePr, getUnresolvedCommentCount, changePrBase, getPrCached, setPrCached, clearPrCache, } from './gh.js';
+const execFileAsync = promisify(execFile);
+export async function enrichBranches(branches, exec) {
+    if (branches.length === 0)
+        return {};
+    // Group by unique repo
+    const repoGroups = new Map();
+    for (const b of branches) {
+        const group = repoGroups.get(b.repoPath) || [];
+        group.push(b);
+        repoGroups.set(b.repoPath, group);
+    }
+    // Batch PR lookups: 1 gh pr list per repo
+    const prMaps = new Map();
+    await Promise.all([...repoGroups.keys()].map(async (repoPath) => {
+        try {
+            prMaps.set(repoPath, await batchGetPrsForRepo(repoPath, { exec }));
+        }
+        catch {
+            prMaps.set(repoPath, new Map());
+        }
+    }));
+    // Enrich each branch in parallel
+    const results = {};
+    await Promise.all(branches.map(async ({ repoPath, branchName }) => {
+        const key = `${repoPath}::${branchName}`;
+        // Batch lookup first; fall back to per-branch call if batch was truncated (--limit 100)
+        let pr = prMaps.get(repoPath)?.get(branchName) ?? null;
+        if (!pr) {
+            try {
+                pr = await getPrForBranch(repoPath, branchName, { exec });
+            }
+            catch {
+                // degrade gracefully
+            }
+        }
+        let stale = false;
+        try {
+            stale = await isBranchStale(repoPath, branchName, { exec });
+        }
+        catch {
+            // default to not stale
+        }
+        results[key] = { pr, stale };
+    }));
+    return results;
+}
+export function createGhRouter(deps) {
+    const exec = deps?.execFileAsync ?? execFileAsync;
+    const router = Router();
+    // POST /gh/enrich-branches — batch enrichment for sidebar
+    router.post('/enrich-branches', async (req, res) => {
+        const raw = req.body?.branches;
+        if (raw !== undefined && !Array.isArray(raw)) {
+            res.status(400).json({ error: 'branches must be an array' });
+            return;
+        }
+        const branches = [];
+        for (const item of (raw ?? [])) {
+            if (!item ||
+                typeof item !== 'object' ||
+                typeof item.repoPath !== 'string' ||
+                typeof item.branchName !== 'string') {
+                res.status(400).json({
+                    error: 'each branch must have string repoPath and branchName',
+                });
+                return;
+            }
+            branches.push({
+                repoPath: item.repoPath,
+                branchName: item.branchName,
+            });
+        }
+        const results = await enrichBranches(branches, exec);
+        res.json({ results });
+    });
+    // GET /gh/pr — single-branch PR detail (for PrTopBar)
+    router.get('/pr', async (req, res) => {
+        const repoPath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        const branch = typeof req.query.branch === 'string' ? req.query.branch : undefined;
+        if (!repoPath || !branch) {
+            res
+                .status(400)
+                .json({ error: 'path and branch query parameters are required' });
+            return;
+        }
+        const cached = getPrCached(repoPath, branch);
+        if (cached) {
+            res.json({ pr: cached.result });
+            return;
+        }
+        try {
+            const pr = await getPrForBranch(repoPath, branch, { exec });
+            if (pr && !isStalePr(pr)) {
+                let unresolvedCommentCount = 0;
+                if (pr.state === 'OPEN') {
+                    try {
+                        unresolvedCommentCount = await getUnresolvedCommentCount(repoPath, pr.number, { exec });
+                    }
+                    catch {
+                        /* degrade gracefully */
+                    }
+                }
+                const enriched = { ...pr, unresolvedCommentCount };
+                setPrCached(repoPath, branch, enriched);
+                res.json({ pr: enriched });
+            }
+            else {
+                setPrCached(repoPath, branch, null);
+                res.json({ pr: null });
+            }
+        }
+        catch {
+            res.json({ pr: null });
+        }
+    });
+    // GET /gh/ci-status — CI check results
+    router.get('/ci-status', async (req, res) => {
+        const repoPath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        const branch = typeof req.query.branch === 'string' ? req.query.branch : undefined;
+        if (!repoPath) {
+            res.status(400).json({ error: 'path query parameter is required' });
+            return;
+        }
+        try {
+            const status = await getCiStatus(repoPath, branch ?? 'HEAD', { exec });
+            res.json(status);
+        }
+        catch {
+            res.json({ total: 0, passing: 0, failing: 0, pending: 0 });
+        }
+    });
+    // POST /gh/pr-base — change PR base branch
+    router.post('/pr-base', async (req, res) => {
+        const repoPath = typeof req.query.path === 'string' ? req.query.path : undefined;
+        const { prNumber, baseBranch } = req.body;
+        if (!repoPath) {
+            res.status(400).json({ error: 'path query parameter required' });
+            return;
+        }
+        if (!prNumber || typeof prNumber !== 'number') {
+            res.status(400).json({ error: 'prNumber is required' });
+            return;
+        }
+        if (!baseBranch || typeof baseBranch !== 'string') {
+            res.status(400).json({ error: 'baseBranch is required' });
+            return;
+        }
+        const result = await changePrBase(repoPath, prNumber, baseBranch, { exec });
+        if (result.success) {
+            clearPrCache(repoPath);
+            res.json(result);
+        }
+        else {
+            res.status(400).json({ error: result.error });
+        }
+    });
+    return router;
+}