@exreve/exk 1.0.50 → 1.0.52

package/dist/cli/githubHandlers.js

@@ -0,0 +1,525 @@
+/**
+ * GitHub Handlers Module
+ *
+ * Extracted from app-child.ts. Provides all git/gh CLI operations
+ * using async execFile (non-blocking). Registered via registerGitHubHandlers().
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+const execFileAsync = promisify(execFile);
+// ============ Helpers ============
+/** Run a git command in a project directory. Returns trimmed stdout. */
+async function git(args, cwd, options) {
+    const { stdout } = await execFileAsync('git', args, {
+        cwd,
+        maxBuffer: options?.maxBuffer ?? 10 * 1024 * 1024,
+    });
+    return (stdout || '').trim();
+}
+/** Run a gh command in a project directory. Returns trimmed stdout. */
+async function gh(args, cwd) {
+    const { stdout } = await execFileAsync('gh', args, {
+        cwd,
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return (stdout || '').trim();
+}
+/** Check if directory is a git repository */
+async function isGitRepo(projectPath) {
+    try {
+        const stat = await fs.stat(path.join(projectPath, '.git'));
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Cached gh CLI availability check */
+let ghCheckCache = { available: false, checked: 0 };
+async function isGhAvailable() {
+    const now = Date.now();
+    if (ghCheckCache.checked && now - ghCheckCache.checked < 60_000)
+        return ghCheckCache.available;
+    try {
+        await execFileAsync('gh', ['auth', 'status'], { timeout: 5000 });
+        ghCheckCache.available = true;
+    }
+    catch {
+        ghCheckCache.available = false;
+    }
+    ghCheckCache.checked = now;
+    return ghCheckCache.available;
+}
+/** Parse error from git/gh CLI output into a user-friendly message */
+function parseError(error) {
+    const stderr = (error.stderr || error.message || '').toString().trim();
+    if (stderr.includes('not a git repository'))
+        return 'Not a git repository';
+    if (stderr.includes('CONFLICT'))
+        return 'Merge conflict detected. Resolve conflicts and try again.';
+    if (stderr.includes('Authentication failed') || stderr.includes('Permission denied'))
+        return 'Authentication failed. Check your git credentials.';
+    if (stderr.includes('gh auth'))
+        return 'GitHub CLI not authenticated. Run: gh auth login';
+    if (stderr.includes('nothing to commit'))
+        return 'Nothing to commit';
+    if (stderr.includes('no upstream'))
+        return 'No upstream branch set. Push with -u flag first.';
+    if (stderr.includes('dirty working tree'))
+        return 'Working tree has uncommitted changes. Commit or stash first.';
+    // Return first line of error, truncated
+    const firstLine = stderr.split('\n')[0];
+    return firstLine.length > 200 ? firstLine.slice(0, 200) + '...' : firstLine || 'Unknown error';
+}
+/** Get current branch name */
+async function getCurrentBranch(cwd) {
+    return git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+}
+// ============ Handler Implementation ============
+/** Parse git status --porcelain output into structured file list */
+function parsePorcelainStatus(output) {
+    if (!output)
+        return [];
+    const files = [];
+    for (const line of output.split('\n')) {
+        if (!line.trim())
+            continue;
+        const x = line[0]; // index status
+        const y = line[1]; // working tree status
+        const filePath = line.substring(3).trim();
+        if (!filePath)
+            continue;
+        const staged = x !== ' ' && x !== '?';
+        const unstaged = y !== ' ' && y !== '?';
+        const status = line.substring(0, 2);
+        files.push({ path: filePath, status, staged, unstaged });
+    }
+    return files;
+}
+/** Handler: github:status — full repo status */
+async function handleStatus(projectPath) {
+    try {
+        const repo = await isGitRepo(projectPath);
+        if (!repo)
+            return { success: true, status: { isRepo: false, branch: '', remote: undefined, ahead: 0, behind: 0, changedFiles: [], stashCount: 0, ghAvailable: false } };
+        const [branch, remote, porcelainOutput, ghOk] = await Promise.all([
+            getCurrentBranch(projectPath).catch(() => ''),
+            git(['config', '--get', 'remote.origin.url'], projectPath).catch(() => ''),
+            git(['status', '--porcelain'], projectPath).catch(() => ''),
+            isGhAvailable(),
+        ]);
+        // Ahead/behind (may fail if no upstream)
+        let ahead = 0, behind = 0;
+        try {
+            const abOutput = await git(['rev-list', '--left-right', '--count', '@{upstream}...HEAD'], projectPath);
+            const parts = abOutput.split(/\s+/);
+            behind = parseInt(parts[0], 10) || 0;
+            ahead = parseInt(parts[1], 10) || 0;
+        }
+        catch {
+            // No upstream configured
+        }
+        // Stash count
+        let stashCount = 0;
+        try {
+            const stashList = await git(['stash', 'list'], projectPath);
+            if (stashList)
+                stashCount = stashList.split('\n').filter(Boolean).length;
+        }
+        catch {
+            // empty
+        }
+        const changedFiles = parsePorcelainStatus(porcelainOutput);
+        const MAX_CHANGED_FILES = 1000;
+        const totalChangedFiles = changedFiles.length;
+        const truncated = totalChangedFiles > MAX_CHANGED_FILES ? changedFiles.slice(0, MAX_CHANGED_FILES) : changedFiles;
+        return {
+            success: true,
+            status: {
+                isRepo: true,
+                branch: branch || 'HEAD',
+                remote: remote || undefined,
+                ahead,
+                behind,
+                changedFiles: truncated,
+                stashCount,
+                ghAvailable: ghOk,
+                ...(totalChangedFiles > MAX_CHANGED_FILES && { totalChangedFiles }),
+            },
+        };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:diff — per-file diff */
+async function handleDiff(projectPath, file, staged) {
+    try {
+        const args = staged ? ['diff', '--cached', '--', file] : ['diff', '--', file];
+        const diffText = await git(args, projectPath);
+        return { success: true, diff: { file, diff: diffText } };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:log — commit history */
+async function handleLog(projectPath, count) {
+    try {
+        const n = count || 15;
+        const format = '%H|%h|%an|%aI|%s|%D';
+        const output = await git(['log', `--pretty=format:${format}`, `-n`, String(n)], projectPath);
+        if (!output)
+            return { success: true, entries: [] };
+        const entries = output.split('\n').filter(Boolean).map(line => {
+            const [hash, shortHash, author, date, message, refs] = line.split('|');
+            return { hash: hash || '', shortHash: shortHash || '', author: author || '', date: date || '', message: message || '', refs: refs || undefined };
+        });
+        return { success: true, entries };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:branches — list branches */
+async function handleBranches(projectPath) {
+    try {
+        const output = await git(['branch', '-a', '--no-color'], projectPath);
+        if (!output)
+            return { success: true, branches: [] };
+        const branches = [];
+        const seen = new Set();
+        for (const line of output.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const current = trimmed.startsWith('* ');
+            let name = current ? trimmed.substring(2) : trimmed;
+            // Skip remote HEAD references
+            if (name.includes('->'))
+                continue;
+            // Normalize remote branches
+            if (name.startsWith('remotes/origin/')) {
+                name = name.replace('remotes/origin/', '');
+                if (name === 'HEAD')
+                    continue;
+            }
+            // Deduplicate (local + remote with same name)
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            branches.push({ name, current });
+        }
+        // Sort: current first, then alphabetically
+        branches.sort((a, b) => {
+            if (a.current && !b.current)
+                return -1;
+            if (!a.current && b.current)
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        return { success: true, branches };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:checkout — switch branch */
+async function handleCheckout(projectPath, branch) {
+    try {
+        await git(['checkout', branch], projectPath);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:create-branch — create and switch to new branch */
+async function handleCreateBranch(projectPath, name, base) {
+    try {
+        const args = base ? ['checkout', '-b', name, base] : ['checkout', '-b', name];
+        await git(args, projectPath);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:add — stage files */
+async function handleAdd(projectPath, files) {
+    try {
+        await git(['add', '--', ...files], projectPath);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:commit — commit staged changes (no auto-push, no auto-add) */
+async function handleCommit(projectPath, message) {
+    try {
+        await git(['commit', '-m', message], projectPath);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:push — push to remote */
+async function handlePush(projectPath, branch) {
+    try {
+        const targetBranch = branch || await getCurrentBranch(projectPath);
+        await git(['push', 'origin', targetBranch], projectPath);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:pull — pull with rebase */
+async function handlePull(projectPath) {
+    try {
+        await git(['pull', '--rebase'], projectPath);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:fetch — fetch and prune */
+async function handleFetch(projectPath) {
+    try {
+        await git(['fetch', '--prune'], projectPath);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:stash — stash or pop */
+async function handleStash(projectPath, pop) {
+    try {
+        if (pop) {
+            await git(['stash', 'pop'], projectPath);
+        }
+        else {
+            await git(['stash', 'push'], projectPath);
+        }
+        // Return updated stash count
+        let stashCount = 0;
+        try {
+            const stashList = await git(['stash', 'list'], projectPath);
+            if (stashList)
+                stashCount = stashList.split('\n').filter(Boolean).length;
+        }
+        catch { /* empty */ }
+        return { success: true, stashCount };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:discard — discard changes */
+async function handleDiscard(projectPath, files) {
+    try {
+        if (files && files.length > 0) {
+            // Discard specific files
+            await git(['checkout', '--', ...files], projectPath);
+        }
+        else {
+            // Discard all changes
+            await git(['reset', '--hard', 'HEAD'], projectPath);
+            try {
+                await git(['clean', '-fd'], projectPath);
+            }
+            catch { /* no untracked files */ }
+        }
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:pr:list — list pull requests via gh CLI */
+async function handlePrList(projectPath, state) {
+    try {
+        const s = state || 'open';
+        const output = await gh(['pr', 'list', '--state', s, '--json', 'number,title,state,author,headRefName,baseRefName,url,createdAt', '--limit', '30'], projectPath);
+        const parsed = JSON.parse(output);
+        const prs = parsed.map(pr => ({
+            number: pr.number,
+            title: pr.title,
+            state: (pr.state || 'OPEN').toUpperCase(),
+            author: pr.author?.login || pr.author?.name || 'unknown',
+            headRefName: pr.headRefName || '',
+            baseRefName: pr.baseRefName || '',
+            url: pr.url || '',
+            createdAt: pr.createdAt || '',
+        }));
+        return { success: true, prs };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:pr:create — create a PR via gh CLI */
+async function handlePrCreate(projectPath, title, body, base, head) {
+    try {
+        const args = ['pr', 'create', '--title', title];
+        if (body)
+            args.push('--body', body);
+        else
+            args.push('--body', '');
+        if (base)
+            args.push('--base', base);
+        if (head)
+            args.push('--head', head);
+        const output = await gh(args, projectPath);
+        // gh pr create returns the URL on success
+        const url = output.split('\n').pop() || output;
+        // Extract PR number from URL
+        const match = url.match(/\/pull\/(\d+)/);
+        const number = match ? parseInt(match[1], 10) : 0;
+        return {
+            success: true,
+            pr: {
+                number,
+                title,
+                state: 'OPEN',
+                author: '',
+                headRefName: head || '',
+                baseRefName: base || '',
+                url,
+                createdAt: new Date().toISOString(),
+            },
+        };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+/** Handler: github:pr:merge — merge a PR via gh CLI */
+async function handlePrMerge(projectPath, prNumber) {
+    try {
+        await gh(['pr', 'merge', String(prNumber), '--squash', '--delete-branch'], projectPath);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: parseError(error) };
+    }
+}
+// ============ Module Registration ============
+/**
+ * Register all GitHub socket handlers on the given socket.
+ * Call this inside the connectAndRegister() function in app-child.ts.
+ */
+export function registerGitHubHandlers(socket, foreground) {
+    socket.on('github:status', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] Status check for ${data.projectId}`);
+        const result = await handleStatus(data.projectPath);
+        if (foreground && result.success) {
+            const s = result.status;
+            console.log(`[github] Status: branch=${s?.branch}, files=${s?.changedFiles.length}, ahead=${s?.ahead}, behind=${s?.behind}`);
+        }
+        callback?.(result);
+    });
+    socket.on('github:diff', async (data, callback) => {
+        const result = await handleDiff(data.projectPath, data.file, data.staged);
+        callback?.(result);
+    });
+    socket.on('github:log', async (data, callback) => {
+        const result = await handleLog(data.projectPath, data.count);
+        callback?.(result);
+    });
+    socket.on('github:branches', async (data, callback) => {
+        const result = await handleBranches(data.projectPath);
+        callback?.(result);
+    });
+    socket.on('github:checkout', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] Checkout: ${data.branch}`);
+        const result = await handleCheckout(data.projectPath, data.branch);
+        if (foreground && result.success)
+            console.log(`[github] Switched to ${data.branch}`);
+        callback?.(result);
+    });
+    socket.on('github:create-branch', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] Create branch: ${data.name}`);
+        const result = await handleCreateBranch(data.projectPath, data.name, data.base);
+        if (foreground && result.success)
+            console.log(`[github] Created and switched to ${data.name}`);
+        callback?.(result);
+    });
+    socket.on('github:add', async (data, callback) => {
+        const result = await handleAdd(data.projectPath, data.files);
+        callback?.(result);
+    });
+    socket.on('github:commit', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] Commit: ${data.message.substring(0, 60)}`);
+        const result = await handleCommit(data.projectPath, data.message);
+        if (foreground && result.success)
+            console.log(`[github] Committed successfully`);
+        callback?.(result);
+    });
+    socket.on('github:push', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] Push`);
+        const result = await handlePush(data.projectPath, data.branch);
+        if (foreground && result.success)
+            console.log(`[github] Pushed successfully`);
+        callback?.(result);
+    });
+    socket.on('github:pull', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] Pull`);
+        const result = await handlePull(data.projectPath);
+        if (foreground && result.success)
+            console.log(`[github] Pulled successfully`);
+        callback?.(result);
+    });
+    socket.on('github:fetch', async (data, callback) => {
+        const result = await handleFetch(data.projectPath);
+        callback?.(result);
+    });
+    socket.on('github:stash', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] Stash ${data.pop ? 'pop' : 'push'}`);
+        const result = await handleStash(data.projectPath, data.pop);
+        callback?.(result);
+    });
+    socket.on('github:discard', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] Discard changes${data.files ? ` (${data.files.length} files)` : ' (all)'}`);
+        const result = await handleDiscard(data.projectPath, data.files);
+        if (foreground && result.success)
+            console.log(`[github] Changes discarded`);
+        callback?.(result);
+    });
+    socket.on('github:pr:list', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] PR list`);
+        const result = await handlePrList(data.projectPath, data.state);
+        callback?.(result);
+    });
+    socket.on('github:pr:create', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] PR create: ${data.title}`);
+        const result = await handlePrCreate(data.projectPath, data.title, data.body, data.base, data.head);
+        if (foreground && result.success)
+            console.log(`[github] PR created: ${result.pr?.url}`);
+        callback?.(result);
+    });
+    socket.on('github:pr:merge', async (data, callback) => {
+        if (foreground)
+            console.log(`[github] PR merge: #${data.number}`);
+        const result = await handlePrMerge(data.projectPath, data.number);
+        if (foreground && result.success)
+            console.log(`[github] PR #${data.number} merged`);
+        callback?.(result);
+    });
+}