@minionry/minion 0.7.36

package/dist/server/services/git/parsers.js

@@ -0,0 +1,401 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { dirname, join } from 'node:path';
+export function redactRemoteCredentials(remoteUrl) {
+    try {
+        const url = new URL(remoteUrl);
+        if (url.username || url.password) {
+            url.username = '';
+            url.password = '';
+            return url.toString();
+        }
+        return remoteUrl;
+    }
+    catch {
+        return remoteUrl;
+    }
+}
+export function detectGitProvider(remoteUrl) {
+    if (remoteUrl.includes('github.com'))
+        return 'github';
+    if (remoteUrl.includes('gitlab.com') || remoteUrl.includes('gitlab'))
+        return 'gitlab';
+    return 'unknown';
+}
+const COAUTHOR_LINE_PATTERNS = [
+    /co-authored-by/i,
+    /authored-by:/i,
+    /generated with .*(claude|anthropic)/i,
+    /noreply@anthropic\.com/i,
+];
+export function stripCoauthorLines(message) {
+    const lines = message.split('\n');
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (COAUTHOR_LINE_PATTERNS.some(p => p.test(lines[i]))) {
+            if (result.length > 0 && result[result.length - 1].trim() === '') {
+                result.pop();
+            }
+            continue;
+        }
+        result.push(lines[i]);
+    }
+    if (result.length === 0)
+        return '';
+    return result.join('\n').trimEnd();
+}
+export function extractCommitMessage(rawOutput) {
+    const output = stripCoauthorLines(rawOutput.trim()).trim();
+    const patterns = [
+        /(?:here'?s?\s+(?:the\s+)?commit\s+message:?\s*\n+)([\s\S]+)/i,
+        /(?:commit\s+message:?\s*\n+)([\s\S]+)/i,
+        /(?:suggested\s+commit\s+message:?\s*\n+)([\s\S]+)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = output.match(pattern);
+        if (match?.[1]) {
+            return match[1].trim();
+        }
+    }
+    const paragraphs = output.split(/\n\n+/).filter(p => p.trim());
+    if (paragraphs.length <= 1) {
+        return output;
+    }
+    const firstParagraph = paragraphs[0].trim();
+    const firstLine = firstParagraph.split('\n')[0].trim();
+    const reasoningPatterns = [
+        /^(Now|Based|Looking|After|Here|Let me|I\s+(can|will|see|notice|'ll|would))/i,
+        /^The\s+\w+\s+(file|changes?|commit|diff)/i,
+        /\b(I can|I will|I'll|let me|analyzing|looking at)\b/i,
+    ];
+    const looksLikeReasoning = reasoningPatterns.some(p => p.test(firstParagraph));
+    const firstLineTooLong = firstLine.length > 80;
+    const endsWithPeriod = firstLine.endsWith('.');
+    if (looksLikeReasoning || (firstLineTooLong && endsWithPeriod)) {
+        const commitMessage = paragraphs.slice(1).join('\n\n').trim();
+        const extractedFirstLine = commitMessage.split('\n')[0].trim();
+        if (extractedFirstLine.length > 0 && extractedFirstLine.length <= 100) {
+            return commitMessage;
+        }
+    }
+    if (paragraphs.length >= 2) {
+        const secondParagraph = paragraphs[1].trim();
+        const secondFirstLine = secondParagraph.split('\n')[0].trim();
+        if (secondFirstLine.length <= 72 &&
+            /^[A-Z][a-z]/.test(secondFirstLine) &&
+            !secondFirstLine.endsWith('.')) {
+            return paragraphs.slice(1).join('\n\n').trim();
+        }
+    }
+    return output;
+}
+const ESCAPE_CHARS = {
+    '\\': '\\',
+    '"': '"',
+    'n': '\n',
+    't': '\t',
+    'r': '\r',
+};
+function isOctalEscape(str, i) {
+    return i + 3 < str.length &&
+        /[0-7]/.test(str[i + 1]) &&
+        /[0-7]{2}/.test(str.slice(i + 2, i + 4));
+}
+export function unquoteGitPath(path) {
+    if (!path.startsWith('"') || !path.endsWith('"')) {
+        return path;
+    }
+    const inner = path.slice(1, -1);
+    let result = '';
+    let i = 0;
+    while (i < inner.length) {
+        if (inner[i] !== '\\' || i + 1 >= inner.length) {
+            result += inner[i];
+            i++;
+            continue;
+        }
+        const next = inner[i + 1];
+        const escaped = ESCAPE_CHARS[next];
+        if (escaped !== undefined) {
+            result += escaped;
+            i += 2;
+        }
+        else if (isOctalEscape(inner, i)) {
+            result += String.fromCharCode(parseInt(inner.slice(i + 1, i + 4), 8));
+            i += 4;
+        }
+        else {
+            result += inner[i];
+            i++;
+        }
+    }
+    return result;
+}
+export function parseGitStatus(porcelainOutput) {
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    const lines = porcelainOutput.split('\n').filter(line => line.length >= 4);
+    for (const line of lines) {
+        const indexStatus = line[0];
+        const workTreeStatus = line[1];
+        const rawPath = line.slice(3);
+        const path = unquoteGitPath(rawPath);
+        let filePath = path;
+        let originalPath;
+        if (rawPath.includes(' -> ')) {
+            const parts = rawPath.split(' -> ');
+            originalPath = unquoteGitPath(parts[0]);
+            filePath = unquoteGitPath(parts[1]);
+        }
+        if (indexStatus === '?' && workTreeStatus === '?') {
+            untracked.push({ path: filePath, status: '?', staged: false });
+            continue;
+        }
+        if (indexStatus !== ' ' && indexStatus !== '?') {
+            staged.push({ path: filePath, status: indexStatus, staged: true, originalPath });
+        }
+        if (workTreeStatus !== ' ' && workTreeStatus !== '?') {
+            unstaged.push({ path: filePath, status: workTreeStatus, staged: false, originalPath });
+        }
+    }
+    return { staged, unstaged, untracked };
+}
+export function parseAheadBehind(countOutput) {
+    const parts = countOutput.trim().split(/\s+/);
+    return {
+        ahead: parseInt(parts[0], 10) || 0,
+        behind: parseInt(parts[1], 10) || 0,
+    };
+}
+function applyWorktreePorcelainLine(line, worktrees, current) {
+    if (line.startsWith('worktree ')) {
+        if (current.path)
+            worktrees.push(current);
+        return { path: line.slice(9).trim(), isMain: false, isBare: false };
+    }
+    if (line.startsWith('HEAD '))
+        current.head = line.slice(5).trim();
+    else if (line.startsWith('branch '))
+        current.branch = line.slice(7).trim().replace('refs/heads/', '');
+    else if (line === 'bare')
+        current.isBare = true;
+    else if (line === 'prunable')
+        current.prunable = true;
+    return current;
+}
+export function parseWorktreePorcelain(stdout) {
+    const worktrees = [];
+    let current = {};
+    for (const line of stdout.split('\n')) {
+        current = applyWorktreePorcelainLine(line, worktrees, current);
+    }
+    if (current.path)
+        worktrees.push(current);
+    if (worktrees.length > 0)
+        worktrees[0].isMain = true;
+    return worktrees;
+}
+export function firstWorktreePath(porcelainOutput) {
+    const firstLine = porcelainOutput.split('\n').find(l => l.startsWith('worktree '));
+    return firstLine ? firstLine.slice(9).trim() : null;
+}
+export function findWorktreePathForBranch(porcelainOutput, branchName) {
+    let currentWtPath = '';
+    const fullRef = `refs/heads/${branchName}`;
+    for (const line of porcelainOutput.split('\n')) {
+        if (line.startsWith('worktree '))
+            currentWtPath = line.slice(9).trim();
+        if (line.startsWith('branch ') && line.slice(7).trim() === fullRef)
+            return currentWtPath;
+    }
+    return null;
+}
+export function deriveWorktreePath(baseDir, branchName) {
+    const repoName = baseDir.split('/').pop() || 'repo';
+    return join(dirname(baseDir), `${repoName}-worktrees`, branchName);
+}
+function applyBranchAbLine(line, summary) {
+    summary.hasUpstream = true;
+    const match = /^# branch\.ab \+(\d+) -(\d+)$/.exec(line);
+    if (!match)
+        return;
+    summary.ahead = parseInt(match[1], 10);
+    summary.behind = parseInt(match[2], 10);
+}
+function applyChangedEntryLine(line, summary) {
+    const xy = line.split(' ')[1] ?? '';
+    if (xy[0] && xy[0] !== '.')
+        summary.staged++;
+    if (xy[1] && xy[1] !== '.')
+        summary.unstaged++;
+}
+function applyStatusLine(line, summary) {
+    if (line.startsWith('# branch.ab '))
+        applyBranchAbLine(line, summary);
+    else if (line.startsWith('1 ') || line.startsWith('2 '))
+        applyChangedEntryLine(line, summary);
+    else if (line.startsWith('u '))
+        summary.unstaged++;
+    else if (line.startsWith('? '))
+        summary.untracked++;
+}
+export function parseWorktreeStatusSummary(porcelainV2) {
+    const summary = { staged: 0, unstaged: 0, untracked: 0, ahead: 0, behind: 0, hasUpstream: false };
+    for (const line of porcelainV2.split('\n')) {
+        applyStatusLine(line, summary);
+    }
+    return summary;
+}
+export const BRANCH_LIST_FORMAT = [
+    '%(refname:short)',
+    '%(objectname:short)',
+    '%(upstream:short)',
+    '%(HEAD)',
+    '%(committerdate:iso8601-strict)',
+    '%(upstream:track)',
+].join('\t');
+export function parseUpstreamTrack(token) {
+    const trimmed = token.trim();
+    if (trimmed === '[gone]')
+        return { ahead: 0, behind: 0, gone: true };
+    const ahead = /\[.*ahead (\d+)/.exec(trimmed);
+    const behind = /(?:\[|, )behind (\d+)/.exec(trimmed);
+    return {
+        ahead: ahead ? parseInt(ahead[1], 10) : 0,
+        behind: behind ? parseInt(behind[1], 10) : 0,
+        gone: false,
+    };
+}
+export function parseBranchLine(line) {
+    const [name, shortHash, upstream, head, committerDate, track] = line.split('\t');
+    if (!name?.trim())
+        return null;
+    const trimmedName = name.trim();
+    const isRemote = trimmedName.includes('/') && (trimmedName.startsWith('origin/') || trimmedName.includes('remotes/'));
+    const hasUpstream = !!upstream?.trim();
+    const tracked = parseUpstreamTrack(track ?? '');
+    return {
+        name: trimmedName,
+        shortHash: shortHash?.trim() || '',
+        isRemote,
+        isCurrent: head?.trim() === '*',
+        upstream: upstream?.trim() || undefined,
+        lastCommitDate: committerDate?.trim() || undefined,
+        ahead: hasUpstream ? tracked.ahead : undefined,
+        behind: hasUpstream ? tracked.behind : undefined,
+        upstreamGone: tracked.gone || undefined,
+    };
+}
+export function parseBranchList(stdout) {
+    return stdout.trim().split('\n')
+        .filter(line => line.trim())
+        .map(parseBranchLine)
+        .filter((b) => b !== null && b.name !== 'origin/HEAD');
+}
+const GIT_LOG_FORMAT = '%H%x00%h%x00%s%x00%an%x00%aI';
+export function buildGitLogArgs(opts) {
+    const { limit, skip, search } = opts;
+    const args = ['log', `-${limit + 1}`, `--skip=${skip}`];
+    const term = search?.trim();
+    if (term) {
+        args.push('-i', '-F', `--grep=${term}`);
+    }
+    args.push(`--format=${GIT_LOG_FORMAT}`);
+    return args;
+}
+export function parseLogEntries(stdout) {
+    return stdout.trim().split('\n').filter(Boolean).map(line => {
+        const parts = line.split('\x00');
+        const cleanSubject = stripCoauthorLines(parts[2] || '') || parts[2] || '';
+        return { hash: parts[0], shortHash: parts[1], subject: cleanSubject, author: parts[3], date: parts[4] };
+    });
+}
+export const TAG_LIST_FORMAT = '%(refname:short)|%(objectname:short)|%(creatordate:iso-strict)|%(subject)';
+export function parseTagList(stdout) {
+    return stdout.trim().split('\n')
+        .filter(line => line.trim())
+        .slice(0, 50)
+        .map(line => {
+        const parts = line.split('|');
+        return {
+            name: parts[0]?.trim() || '',
+            shortHash: parts[1]?.trim() || '',
+            date: parts[2]?.trim() || '',
+            message: parts[3]?.trim() || '',
+        };
+    });
+}
+function parseStatusLine(line) {
+    if (!line)
+        return { status: 'M' };
+    const parts = line.split('\t');
+    const status = (parts[0] || 'M').charAt(0);
+    const oldPath = (status === 'R' || status === 'C') && parts.length >= 3 ? parts[1] : undefined;
+    return { status, oldPath };
+}
+export function parseCommitFiles(numstatOutput, statusOutput) {
+    const numstatLines = numstatOutput.trim().split('\n').filter(Boolean);
+    const statusLines = statusOutput.trim().split('\n').filter(Boolean);
+    return numstatLines.map((line, i) => {
+        const numParts = line.split('\t');
+        const additions = numParts[0] === '-' ? 0 : parseInt(numParts[0], 10) || 0;
+        const deletions = numParts[1] === '-' ? 0 : parseInt(numParts[1], 10) || 0;
+        const { status, oldPath } = parseStatusLine(statusLines[i]);
+        return { path: numParts[2] || '', status, additions, deletions, ...(oldPath ? { oldPath } : {}) };
+    });
+}
+export function parseMergeTreeConflicts(stdout) {
+    return stdout.split('\n')
+        .filter(line => line.includes('CONFLICT'))
+        .map(line => {
+        const match = line.match(/CONFLICT.*:\s+(.+)/);
+        return match?.[1]?.trim() || line;
+    });
+}
+export function parseMergeTreeOid(stdout) {
+    return stdout.split('\n', 1)[0].trim();
+}
+export function parseMergeCommits(stdout) {
+    return stdout.trim().split('\n')
+        .filter(line => line.trim())
+        .map(line => {
+        const [hash, ...rest] = line.split('|');
+        return { hash: hash.trim(), message: rest.join('|').trim() };
+    });
+}
+export function parseOverwritePaths(stderr) {
+    const lines = stderr.split('\n');
+    const headerIdx = lines.findIndex(l => /your local changes to the following files would be overwritten/i.test(l) ||
+        /untracked working tree files would be overwritten/i.test(l));
+    if (headerIdx < 0)
+        return [];
+    const paths = [];
+    for (let i = headerIdx + 1; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (/^(merge with strategy|aborting|please commit)/i.test(trimmed))
+            break;
+        if (/^[\t ]/.test(line)) {
+            paths.push(trimmed);
+        }
+    }
+    return paths;
+}
+export function isSafeDiscardPath(p) {
+    if (typeof p !== 'string' || p.length === 0)
+        return false;
+    if (p === '.' || p === './')
+        return false;
+    if (p.startsWith('/') || p.startsWith('~'))
+        return false;
+    if (p.startsWith(':'))
+        return false;
+    if (p.split(/[/\\]/).includes('..'))
+        return false;
+    if (/[*?[\]]/.test(p))
+        return false;
+    return true;
+}

package/dist/server/services/git/remote-ops.js

@@ -0,0 +1,192 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { loadSkillPrompt } from '../plan/agent-loader.js';
+import { getPrBaseBranch, setPrBaseBranch } from '../settings.js';
+import { executeGitCommand, spawnCheck, spawnWithOutput } from './command.js';
+import { spawnHaikuWithPrompt, truncateDiff } from './haiku.js';
+import { detectGitProvider, redactRemoteCredentials, stripCoauthorLines } from './parsers.js';
+import { gitFail, gitOk } from './types.js';
+async function getDefaultBranch(workingDir) {
+    const result = await executeGitCommand(['symbolic-ref', 'refs/remotes/origin/HEAD', '--short'], workingDir);
+    return result.exitCode === 0 ? result.stdout.trim().replace('origin/', '') : 'main';
+}
+async function checkGitCliStatus(provider) {
+    const cliBin = provider === 'github' ? 'gh' : provider === 'gitlab' ? 'glab' : null;
+    if (!cliBin)
+        return { hasGhCli: false, ghCliAuthenticated: false };
+    const installed = await spawnCheck(cliBin, ['--version']);
+    if (!installed)
+        return { hasGhCli: false, ghCliAuthenticated: false };
+    const authenticated = await spawnCheck(cliBin, ['auth', 'status']);
+    return { hasGhCli: true, ghCliAuthenticated: authenticated, ghCliBinary: cliBin };
+}
+async function listRemoteBranches(workingDir) {
+    const result = await executeGitCommand(['branch', '-r', '--list', 'origin/*'], workingDir);
+    if (result.exitCode !== 0)
+        return [];
+    return result.stdout.split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.includes('->'))
+        .map(line => line.replace('origin/', ''))
+        .filter(Boolean)
+        .sort();
+}
+export async function readRemoteInfo({ cwd }) {
+    const remoteResult = await executeGitCommand(['remote', 'get-url', 'origin'], cwd);
+    if (remoteResult.exitCode !== 0) {
+        return { hasRemote: false };
+    }
+    const remoteUrl = remoteResult.stdout.trim();
+    const provider = detectGitProvider(remoteUrl);
+    const defaultBranch = await getDefaultBranch(cwd);
+    const branchResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    const currentBranch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : '';
+    const cliStatus = await checkGitCliStatus(provider);
+    const remoteBranches = await listRemoteBranches(cwd);
+    const preferredBaseBranch = getPrBaseBranch(remoteUrl) ?? undefined;
+    return {
+        hasRemote: true,
+        remoteUrl: redactRemoteCredentials(remoteUrl),
+        provider,
+        defaultBranch,
+        currentBranch,
+        ...cliStatus,
+        remoteBranches,
+        preferredBaseBranch,
+    };
+}
+function detectPRCliBin(remoteUrl) {
+    const isGitHub = remoteUrl.includes('github.com');
+    const isGitLab = remoteUrl.includes('gitlab.com') || remoteUrl.includes('gitlab');
+    const cliBin = isGitHub ? 'gh' : isGitLab ? 'glab' : null;
+    return { cliBin, isGitHub, isGitLab };
+}
+async function ensureBranchPushed(headBranch, workingDir) {
+    const upstreamCheck = await executeGitCommand(['rev-parse', '--abbrev-ref', `${headBranch}@{u}`], workingDir);
+    const hasUpstream = upstreamCheck.exitCode === 0;
+    let needsPush = !hasUpstream;
+    if (hasUpstream) {
+        const aheadCheck = await executeGitCommand(['rev-list', '--count', `@{u}..HEAD`], workingDir);
+        needsPush = aheadCheck.exitCode === 0 && parseInt(aheadCheck.stdout.trim(), 10) > 0;
+    }
+    if (!needsPush)
+        return null;
+    const pushArgs = hasUpstream ? ['push'] : ['push', '-u', 'origin', headBranch];
+    const pushResult = await executeGitCommand(pushArgs, workingDir);
+    if (pushResult.exitCode !== 0) {
+        return `Failed to push branch before creating PR: ${pushResult.stderr || pushResult.stdout}`;
+    }
+    return null;
+}
+function classifyCliPRError(cliBin, result, headBranch) {
+    const combined = result.stderr + result.stdout;
+    const lower = combined.toLowerCase();
+    if (lower.includes('already exists')) {
+        const existingUrl = combined.match(/https?:\/\/\S+/);
+        return existingUrl
+            ? `A pull request already exists for ${headBranch}: ${existingUrl[0]}`
+            : `A pull request already exists for ${headBranch}`;
+    }
+    if (lower.includes('auth') || lower.includes('401') || lower.includes('token') || lower.includes('log in')) {
+        return `${cliBin} is not authenticated. Run: ${cliBin} auth login`;
+    }
+    if (lower.includes('must first push') || lower.includes('failed to push') || lower.includes('no upstream')) {
+        return `Branch "${headBranch}" has not been pushed to remote. Push first, then create the PR.`;
+    }
+    return `${cliBin} failed: ${(result.stderr || result.stdout).trim()}`;
+}
+async function tryCliPRCreate(cliBin, opts, workingDir) {
+    if (!cliBin)
+        return { created: false };
+    const installed = await spawnCheck(cliBin, ['--version']);
+    if (!installed)
+        return { created: false };
+    const args = cliBin === 'gh'
+        ? ['pr', 'create', '--title', opts.title]
+        : ['mr', 'create', '--title', opts.title, '--yes'];
+    if (opts.body)
+        args.push('--body', opts.body);
+    if (opts.baseBranch) {
+        args.push(cliBin === 'gh' ? '--base' : '--target-branch', opts.baseBranch);
+    }
+    if (opts.draft)
+        args.push('--draft');
+    const result = await spawnWithOutput(cliBin, args, workingDir);
+    if (result.exitCode === 0) {
+        const urlMatch = result.stdout.match(/https?:\/\/\S+/);
+        return { created: true, url: urlMatch ? urlMatch[0] : result.stdout.trim() };
+    }
+    return { created: false, error: classifyCliPRError(cliBin, result, opts.headBranch) };
+}
+function buildBrowserPRUrl(remoteUrl, headBranch, baseBranch, title, body, isGitHub, isGitLab) {
+    const sshMatch = remoteUrl.match(/[:/]([^/]+)\/([^/.]+)(?:\.git)?$/);
+    if (!sshMatch)
+        return '';
+    const [, owner, repo] = sshMatch;
+    const base = baseBranch || 'main';
+    if (isGitHub) {
+        return `https://github.com/${owner}/${repo}/compare/${base}...${headBranch}?expand=1&title=${encodeURIComponent(title)}${body ? `&body=${encodeURIComponent(body)}` : ''}`;
+    }
+    if (isGitLab) {
+        return `https://gitlab.com/${owner}/${repo}/-/merge_requests/new?merge_request[source_branch]=${headBranch}&merge_request[target_branch]=${base}&merge_request[title]=${encodeURIComponent(title)}`;
+    }
+    return '';
+}
+export async function createPullRequest({ cwd, title, body, baseBranch, draft }) {
+    const branchResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    if (branchResult.exitCode !== 0) {
+        return gitFail('Failed to detect current branch');
+    }
+    const remoteResult = await executeGitCommand(['remote', 'get-url', 'origin'], cwd);
+    if (remoteResult.exitCode !== 0) {
+        return gitFail('No remote origin configured');
+    }
+    const headBranch = branchResult.stdout.trim();
+    const remoteUrl = remoteResult.stdout.trim();
+    const { cliBin, isGitHub, isGitLab } = detectPRCliBin(remoteUrl);
+    const pushError = await ensureBranchPushed(headBranch, cwd);
+    if (pushError) {
+        return gitFail(pushError);
+    }
+    const cliResult = await tryCliPRCreate(cliBin, { title, body, baseBranch, draft, headBranch }, cwd);
+    if (cliResult.created) {
+        if (baseBranch)
+            setPrBaseBranch(remoteUrl, baseBranch);
+        return gitOk({ url: cliResult.url, method: isGitHub ? 'gh' : 'glab' });
+    }
+    if (cliResult.error) {
+        return gitFail(cliResult.error);
+    }
+    const prUrl = buildBrowserPRUrl(remoteUrl, headBranch, baseBranch, title, body, isGitHub, isGitLab);
+    if (!prUrl) {
+        return gitFail('Could not determine remote URL format for PR creation');
+    }
+    if (baseBranch)
+        setPrBaseBranch(remoteUrl, baseBranch);
+    return gitOk({ url: prUrl, method: 'browser' });
+}
+const PR_DESCRIPTION_SYSTEM_PROMPT = 'You are a pull request description assistant. Respond with only the PR title and description, no preamble or explanation.';
+export async function generatePrDescription({ cwd, baseBranch }) {
+    const remoteBase = `origin/${baseBranch}`;
+    const remoteRefCheck = await executeGitCommand(['rev-parse', '--verify', remoteBase], cwd);
+    const compareRef = remoteRefCheck.exitCode === 0 ? remoteBase : baseBranch;
+    const logResult = await executeGitCommand(['log', `${compareRef}..HEAD`, '--oneline'], cwd);
+    const commits = logResult.exitCode === 0 ? logResult.stdout.trim() : '';
+    if (!commits) {
+        return gitFail(`No commits found between ${baseBranch} and HEAD`);
+    }
+    const diffResult = await executeGitCommand(['diff', `${compareRef}...HEAD`], cwd);
+    const statResult = await executeGitCommand(['diff', `${compareRef}...HEAD`, '--stat'], cwd);
+    const filesChanged = statResult.exitCode === 0 ? statResult.stdout.trim() : '';
+    const diff = truncateDiff(diffResult.exitCode === 0 ? diffResult.stdout : '');
+    const prompt = loadSkillPrompt('pr-description', { baseBranch, commits, filesChanged, diff }, cwd)
+        ?? `You are generating a pull request title and description.\n\nCOMMITS (${baseBranch}..HEAD):\n${commits}\n\nFILES CHANGED:\n${filesChanged}\n\nDIFF:\n${diff}\n\nGenerate PR title (imperative, <70 chars) then body with ## Summary (1-3 bullets). No emojis. Respond with ONLY the title and description.`;
+    const result = await spawnHaikuWithPrompt(prompt, PR_DESCRIPTION_SYSTEM_PROMPT, cwd);
+    if (result.exitCode !== 0 || !result.stdout.trim()) {
+        console.error('[WebSocketImproviseHandler] Claude PR description error:', result.stderr || 'No output');
+        return gitFail('Failed to generate PR description');
+    }
+    const output = stripCoauthorLines(result.stdout.trim());
+    const lines = output.split('\n');
+    return gitOk({ title: lines[0].trim(), body: lines.slice(1).join('\n').trim() });
+}