difit 3.1.18 → 4.0.1

package/dist/cli/github.js

@@ -0,0 +1,296 @@
+import { execFileSync } from 'child_process';
+const PR_REVIEW_THREADS_GRAPHQL_QUERY = `
+query($owner: String!, $repo: String!, $number: Int!, $endCursor: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100, after: $endCursor) {
+        nodes {
+          id
+          isResolved
+          isOutdated
+          subjectType
+          path
+          diffSide
+          startDiffSide
+          line
+          startLine
+          originalLine
+          originalStartLine
+          comments(first: 100) {
+            nodes {
+              id
+              body
+              createdAt
+              updatedAt
+              author {
+                login
+              }
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  }
+}
+`;
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+function formatGhCommandError(error) {
+    const stderr = error.stderr;
+    const stderrText = typeof stderr === 'string'
+        ? stderr.trim()
+        : Buffer.isBuffer(stderr)
+            ? stderr.toString('utf8').trim()
+            : '';
+    const message = stderrText || (error instanceof Error ? error.message : 'Unknown error while running gh');
+    return new Error(`${message}\nTry: gh auth login`);
+}
+function warnPrCommentImport(threadId, message) {
+    const threadLabel = threadId ? ` ${threadId}` : '';
+    console.warn(`Warning: Skipping PR review thread${threadLabel}: ${message}`);
+}
+function createSingleLinePosition(side, line) {
+    return { side, line };
+}
+function createMultiLinePosition(side, start, end) {
+    const line = { start, end };
+    return { side, line };
+}
+function createRightSidePosition(thread) {
+    if (!isPositiveInteger(thread.line)) {
+        warnPrCommentImport(thread.id ?? undefined, 'RIGHT thread is missing line.');
+        return null;
+    }
+    const startLine = thread.startLine !== undefined && thread.startLine !== null ? thread.startLine : null;
+    const isSingleLineWithRedundantStart = startLine !== null && startLine === thread.line && thread.startDiffSide == null;
+    const hasMultiLineMetadata = thread.startDiffSide !== undefined && thread.startDiffSide !== null
+        ? true
+        : startLine !== null && !isSingleLineWithRedundantStart;
+    if (!hasMultiLineMetadata) {
+        return createSingleLinePosition('new', thread.line);
+    }
+    if (thread.startDiffSide !== 'RIGHT') {
+        warnPrCommentImport(thread.id ?? undefined, 'RIGHT thread has mismatched startDiffSide.');
+        return null;
+    }
+    if (!isPositiveInteger(startLine) || startLine > thread.line) {
+        warnPrCommentImport(thread.id ?? undefined, 'RIGHT thread has an invalid multi-line range.');
+        return null;
+    }
+    return createMultiLinePosition('new', startLine, thread.line);
+}
+function createLeftSidePosition(thread) {
+    if (!isPositiveInteger(thread.originalLine)) {
+        warnPrCommentImport(thread.id ?? undefined, 'LEFT thread is missing originalLine.');
+        return null;
+    }
+    const originalStartLine = thread.originalStartLine !== undefined && thread.originalStartLine !== null
+        ? thread.originalStartLine
+        : null;
+    const isSingleLineWithRedundantStart = originalStartLine !== null &&
+        originalStartLine === thread.originalLine &&
+        thread.startDiffSide == null;
+    const hasMultiLineMetadata = thread.startDiffSide !== undefined && thread.startDiffSide !== null
+        ? true
+        : originalStartLine !== null && !isSingleLineWithRedundantStart;
+    if (!hasMultiLineMetadata) {
+        return createSingleLinePosition('old', thread.originalLine);
+    }
+    if (thread.startDiffSide !== 'LEFT') {
+        warnPrCommentImport(thread.id ?? undefined, 'LEFT thread has mismatched startDiffSide.');
+        return null;
+    }
+    if (!isPositiveInteger(originalStartLine) || originalStartLine > thread.originalLine) {
+        warnPrCommentImport(thread.id ?? undefined, 'LEFT thread has an invalid multi-line range.');
+        return null;
+    }
+    return createMultiLinePosition('old', originalStartLine, thread.originalLine);
+}
+function getThreadPosition(thread) {
+    if (thread.diffSide === 'RIGHT') {
+        return createRightSidePosition(thread);
+    }
+    if (thread.diffSide === 'LEFT') {
+        return createLeftSidePosition(thread);
+    }
+    warnPrCommentImport(thread.id ?? undefined, 'Unsupported diffSide.');
+    return null;
+}
+function toSortedComments(thread) {
+    return [...(thread.comments?.nodes ?? [])].sort((left, right) => (left.createdAt ?? '').localeCompare(right.createdAt ?? ''));
+}
+function toCommentImportsForThread(thread) {
+    if (thread.isResolved || thread.isOutdated || thread.subjectType !== 'LINE') {
+        return [];
+    }
+    if (typeof thread.path !== 'string' || thread.path.trim().length === 0) {
+        warnPrCommentImport(thread.id ?? undefined, 'Thread is missing path.');
+        return [];
+    }
+    const filePath = thread.path;
+    const position = getThreadPosition(thread);
+    if (!position) {
+        return [];
+    }
+    const comments = toSortedComments(thread);
+    if (comments.length === 0) {
+        warnPrCommentImport(thread.id ?? undefined, 'Thread has no comments.');
+        return [];
+    }
+    const rootComment = comments[0];
+    if (!rootComment ||
+        typeof rootComment.id !== 'string' ||
+        typeof rootComment.body !== 'string' ||
+        typeof rootComment.createdAt !== 'string' ||
+        typeof rootComment.updatedAt !== 'string') {
+        warnPrCommentImport(thread.id ?? undefined, 'Thread has a comment with missing fields.');
+        return [];
+    }
+    const commentImports = [
+        {
+            type: 'thread',
+            id: rootComment.id,
+            filePath,
+            position,
+            body: rootComment.body,
+            author: rootComment.author?.login ?? undefined,
+            createdAt: rootComment.createdAt,
+            updatedAt: rootComment.updatedAt,
+        },
+    ];
+    for (const comment of comments.slice(1)) {
+        if (typeof comment.id !== 'string' ||
+            typeof comment.body !== 'string' ||
+            typeof comment.createdAt !== 'string' ||
+            typeof comment.updatedAt !== 'string') {
+            warnPrCommentImport(thread.id ?? undefined, 'Thread has a comment with missing fields.');
+            continue;
+        }
+        commentImports.push({
+            type: 'reply',
+            id: comment.id,
+            filePath,
+            position,
+            body: comment.body,
+            author: comment.author?.login ?? undefined,
+            createdAt: comment.createdAt,
+            updatedAt: comment.updatedAt,
+        });
+    }
+    return commentImports;
+}
+export function parseGitHubPrUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        const pathParts = urlObj.pathname.split('/').filter(Boolean);
+        if (pathParts.length < 4 || pathParts[2] !== 'pull') {
+            return null;
+        }
+        const owner = pathParts[0];
+        const repo = pathParts[1];
+        const pullNumber = parseInt(pathParts[3], 10);
+        if (isNaN(pullNumber)) {
+            return null;
+        }
+        return { owner, repo, pullNumber, hostname: urlObj.hostname };
+    }
+    catch {
+        return null;
+    }
+}
+export function getPrPatch(prArg) {
+    try {
+        const patch = execFileSync('gh', ['pr', 'diff', prArg], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        if (!patch.trim()) {
+            throw new Error('No diff content returned from gh pr diff');
+        }
+        return patch;
+    }
+    catch (error) {
+        throw formatGhCommandError(error);
+    }
+}
+export function parsePrCommentImportsResponse(response) {
+    const errors = response.errors?.map((error) => error.message).filter((message) => message) ?? [];
+    if (errors.length > 0) {
+        throw new Error(errors.join('\n'));
+    }
+    const reviewThreads = response.data?.repository?.pullRequest?.reviewThreads;
+    if (!reviewThreads) {
+        return {
+            commentImports: [],
+            pageInfo: {
+                hasNextPage: false,
+                endCursor: null,
+            },
+        };
+    }
+    return {
+        commentImports: (reviewThreads.nodes ?? []).flatMap((thread) => toCommentImportsForThread(thread)),
+        pageInfo: {
+            hasNextPage: reviewThreads.pageInfo?.hasNextPage === true,
+            endCursor: reviewThreads.pageInfo?.endCursor ?? null,
+        },
+    };
+}
+export function getPrCommentImports(prArg) {
+    const pullRequestInfo = parseGitHubPrUrl(prArg);
+    if (!pullRequestInfo) {
+        throw new Error('Invalid GitHub PR URL');
+    }
+    const { owner, repo, pullNumber, hostname } = pullRequestInfo;
+    const commentImports = [];
+    let endCursor = null;
+    while (true) {
+        try {
+            const args = [
+                'api',
+                'graphql',
+                '--hostname',
+                hostname,
+                '-f',
+                `query=${PR_REVIEW_THREADS_GRAPHQL_QUERY}`,
+                '-F',
+                `owner=${owner}`,
+                '-F',
+                `repo=${repo}`,
+                '-F',
+                `number=${pullNumber}`,
+            ];
+            if (endCursor) {
+                args.push('-F', `endCursor=${endCursor}`);
+            }
+            const stdout = execFileSync('gh', args, {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const parsed = JSON.parse(stdout);
+            const page = parsePrCommentImportsResponse(parsed);
+            commentImports.push(...page.commentImports);
+            if (!page.pageInfo.hasNextPage) {
+                return Promise.resolve(commentImports);
+            }
+            if (!page.pageInfo.endCursor) {
+                throw new Error('GitHub GraphQL response indicated more pages without endCursor.');
+            }
+            endCursor = page.pageInfo.endCursor;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error('Invalid JSON returned from gh api graphql');
+            }
+            if (error instanceof Error && !('stderr' in error)) {
+                throw error;
+            }
+            throw formatGhCommandError(error);
+        }
+    }
+}

package/dist/cli/github.test.d.ts

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

package/dist/cli/github.test.js

@@ -0,0 +1,341 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { parseGitHubPrUrl, parsePrCommentImportsResponse } from './github';
+function createReviewComment(overrides = {}) {
+    return {
+        id: 'COMMENT_1',
+        body: 'Imported comment',
+        createdAt: '2026-03-25T09:00:00Z',
+        updatedAt: '2026-03-25T09:05:00Z',
+        author: { login: 'octocat' },
+        ...overrides,
+    };
+}
+function createReviewThread(overrides = {}) {
+    return {
+        id: 'THREAD_1',
+        isResolved: false,
+        isOutdated: false,
+        subjectType: 'LINE',
+        path: 'src/example.ts',
+        diffSide: 'RIGHT',
+        startDiffSide: null,
+        line: 12,
+        startLine: null,
+        originalLine: 11,
+        originalStartLine: null,
+        comments: {
+            nodes: [createReviewComment()],
+        },
+        ...overrides,
+    };
+}
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe('CLI GitHub utils', () => {
+    describe('parsePrCommentImportsResponse', () => {
+        it('imports unresolved inline threads, sorts comments, and skips non-importable threads', () => {
+            const response = {
+                data: {
+                    repository: {
+                        pullRequest: {
+                            reviewThreads: {
+                                nodes: [
+                                    createReviewThread({
+                                        id: 'THREAD_UNRESOLVED',
+                                        diffSide: 'RIGHT',
+                                        line: 14,
+                                        comments: {
+                                            nodes: [
+                                                createReviewComment({
+                                                    id: 'COMMENT_REPLY',
+                                                    body: 'Second comment',
+                                                    createdAt: '2026-03-25T09:10:00Z',
+                                                    updatedAt: '2026-03-25T09:12:00Z',
+                                                    author: { login: 'reviewer-2' },
+                                                }),
+                                                createReviewComment({
+                                                    id: 'COMMENT_ROOT',
+                                                    body: 'First comment',
+                                                    createdAt: '2026-03-25T09:00:00Z',
+                                                    updatedAt: '2026-03-25T09:05:00Z',
+                                                    author: { login: 'reviewer-1' },
+                                                }),
+                                            ],
+                                        },
+                                    }),
+                                    createReviewThread({
+                                        id: 'THREAD_RESOLVED',
+                                        isResolved: true,
+                                    }),
+                                    createReviewThread({
+                                        id: 'THREAD_OUTDATED',
+                                        isOutdated: true,
+                                    }),
+                                    createReviewThread({
+                                        id: 'THREAD_FILE',
+                                        subjectType: 'FILE',
+                                    }),
+                                ],
+                                pageInfo: {
+                                    hasNextPage: true,
+                                    endCursor: 'CURSOR_1',
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const result = parsePrCommentImportsResponse(response);
+            expect(result).toEqual({
+                commentImports: [
+                    {
+                        type: 'thread',
+                        id: 'COMMENT_ROOT',
+                        filePath: 'src/example.ts',
+                        position: { side: 'new', line: 14 },
+                        body: 'First comment',
+                        author: 'reviewer-1',
+                        createdAt: '2026-03-25T09:00:00Z',
+                        updatedAt: '2026-03-25T09:05:00Z',
+                    },
+                    {
+                        type: 'reply',
+                        id: 'COMMENT_REPLY',
+                        filePath: 'src/example.ts',
+                        position: { side: 'new', line: 14 },
+                        body: 'Second comment',
+                        author: 'reviewer-2',
+                        createdAt: '2026-03-25T09:10:00Z',
+                        updatedAt: '2026-03-25T09:12:00Z',
+                    },
+                ],
+                pageInfo: {
+                    hasNextPage: true,
+                    endCursor: 'CURSOR_1',
+                },
+            });
+        });
+        it('maps RIGHT and LEFT threads to new and old diff positions for single and multi-line comments', () => {
+            const response = {
+                data: {
+                    repository: {
+                        pullRequest: {
+                            reviewThreads: {
+                                nodes: [
+                                    createReviewThread({
+                                        id: 'THREAD_RIGHT_SINGLE',
+                                        diffSide: 'RIGHT',
+                                        line: 20,
+                                        startLine: 20,
+                                        startDiffSide: null,
+                                        comments: {
+                                            nodes: [createReviewComment({ id: 'COMMENT_RIGHT_SINGLE' })],
+                                        },
+                                    }),
+                                    createReviewThread({
+                                        id: 'THREAD_RIGHT_MULTI',
+                                        diffSide: 'RIGHT',
+                                        line: 24,
+                                        startLine: 21,
+                                        startDiffSide: 'RIGHT',
+                                        comments: {
+                                            nodes: [createReviewComment({ id: 'COMMENT_RIGHT_MULTI' })],
+                                        },
+                                    }),
+                                    createReviewThread({
+                                        id: 'THREAD_LEFT_SINGLE',
+                                        diffSide: 'LEFT',
+                                        line: null,
+                                        originalLine: 8,
+                                        originalStartLine: null,
+                                        startDiffSide: null,
+                                        comments: {
+                                            nodes: [createReviewComment({ id: 'COMMENT_LEFT_SINGLE' })],
+                                        },
+                                    }),
+                                    createReviewThread({
+                                        id: 'THREAD_LEFT_MULTI',
+                                        diffSide: 'LEFT',
+                                        line: null,
+                                        originalLine: 11,
+                                        originalStartLine: 7,
+                                        startDiffSide: 'LEFT',
+                                        comments: {
+                                            nodes: [createReviewComment({ id: 'COMMENT_LEFT_MULTI' })],
+                                        },
+                                    }),
+                                ],
+                                pageInfo: {
+                                    hasNextPage: false,
+                                    endCursor: null,
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const result = parsePrCommentImportsResponse(response);
+            expect(result.commentImports).toEqual([
+                {
+                    type: 'thread',
+                    id: 'COMMENT_RIGHT_SINGLE',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 20 },
+                    body: 'Imported comment',
+                    author: 'octocat',
+                    createdAt: '2026-03-25T09:00:00Z',
+                    updatedAt: '2026-03-25T09:05:00Z',
+                },
+                {
+                    type: 'thread',
+                    id: 'COMMENT_RIGHT_MULTI',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: { start: 21, end: 24 } },
+                    body: 'Imported comment',
+                    author: 'octocat',
+                    createdAt: '2026-03-25T09:00:00Z',
+                    updatedAt: '2026-03-25T09:05:00Z',
+                },
+                {
+                    type: 'thread',
+                    id: 'COMMENT_LEFT_SINGLE',
+                    filePath: 'src/example.ts',
+                    position: { side: 'old', line: 8 },
+                    body: 'Imported comment',
+                    author: 'octocat',
+                    createdAt: '2026-03-25T09:00:00Z',
+                    updatedAt: '2026-03-25T09:05:00Z',
+                },
+                {
+                    type: 'thread',
+                    id: 'COMMENT_LEFT_MULTI',
+                    filePath: 'src/example.ts',
+                    position: { side: 'old', line: { start: 7, end: 11 } },
+                    body: 'Imported comment',
+                    author: 'octocat',
+                    createdAt: '2026-03-25T09:00:00Z',
+                    updatedAt: '2026-03-25T09:05:00Z',
+                },
+            ]);
+        });
+        it('warns and skips threads with invalid line mapping', () => {
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const response = {
+                data: {
+                    repository: {
+                        pullRequest: {
+                            reviewThreads: {
+                                nodes: [
+                                    createReviewThread({
+                                        id: 'THREAD_RIGHT_MISSING_LINE',
+                                        diffSide: 'RIGHT',
+                                        line: null,
+                                    }),
+                                    createReviewThread({
+                                        id: 'THREAD_LEFT_MISSING_ORIGINAL',
+                                        diffSide: 'LEFT',
+                                        line: null,
+                                        originalLine: null,
+                                    }),
+                                    createReviewThread({
+                                        id: 'THREAD_RIGHT_BAD_RANGE',
+                                        diffSide: 'RIGHT',
+                                        line: 9,
+                                        startLine: 12,
+                                        startDiffSide: 'RIGHT',
+                                    }),
+                                    createReviewThread({
+                                        id: 'THREAD_LEFT_BAD_SIDE',
+                                        diffSide: 'LEFT',
+                                        line: null,
+                                        originalLine: 9,
+                                        originalStartLine: 7,
+                                        startDiffSide: 'RIGHT',
+                                    }),
+                                ],
+                                pageInfo: {
+                                    hasNextPage: false,
+                                    endCursor: null,
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const result = parsePrCommentImportsResponse(response);
+            expect(result.commentImports).toEqual([]);
+            expect(warnSpy).toHaveBeenCalledTimes(4);
+            expect(warnSpy).toHaveBeenNthCalledWith(1, 'Warning: Skipping PR review thread THREAD_RIGHT_MISSING_LINE: RIGHT thread is missing line.');
+            expect(warnSpy).toHaveBeenNthCalledWith(2, 'Warning: Skipping PR review thread THREAD_LEFT_MISSING_ORIGINAL: LEFT thread is missing originalLine.');
+            expect(warnSpy).toHaveBeenNthCalledWith(3, 'Warning: Skipping PR review thread THREAD_RIGHT_BAD_RANGE: RIGHT thread has an invalid multi-line range.');
+            expect(warnSpy).toHaveBeenNthCalledWith(4, 'Warning: Skipping PR review thread THREAD_LEFT_BAD_SIDE: LEFT thread has mismatched startDiffSide.');
+        });
+    });
+    describe('parseGitHubPrUrl', () => {
+        it('should parse valid GitHub PR URLs', () => {
+            const result = parseGitHubPrUrl('https://github.com/owner/repo/pull/123');
+            expect(result).toEqual({
+                owner: 'owner',
+                repo: 'repo',
+                pullNumber: 123,
+                hostname: 'github.com',
+            });
+        });
+        it('should parse GitHub PR URLs with additional path segments', () => {
+            const result = parseGitHubPrUrl('https://github.com/owner/repo/pull/456/files');
+            expect(result).toEqual({
+                owner: 'owner',
+                repo: 'repo',
+                pullNumber: 456,
+                hostname: 'github.com',
+            });
+        });
+        it('should parse GitHub PR URLs with query parameters', () => {
+            const result = parseGitHubPrUrl('https://github.com/owner/repo/pull/789?tab=files');
+            expect(result).toEqual({
+                owner: 'owner',
+                repo: 'repo',
+                pullNumber: 789,
+                hostname: 'github.com',
+            });
+        });
+        it('should handle URLs with hyphens and underscores in owner/repo names', () => {
+            const result = parseGitHubPrUrl('https://github.com/owner-name/repo_name/pull/123');
+            expect(result).toEqual({
+                owner: 'owner-name',
+                repo: 'repo_name',
+                pullNumber: 123,
+                hostname: 'github.com',
+            });
+        });
+        it('should parse GitHub Enterprise PR URLs', () => {
+            const result1 = parseGitHubPrUrl('https://github.enterprise.com/owner/repo/pull/123');
+            expect(result1).toEqual({
+                owner: 'owner',
+                repo: 'repo',
+                pullNumber: 123,
+                hostname: 'github.enterprise.com',
+            });
+            const result2 = parseGitHubPrUrl('https://git.company.io/team/project/pull/456');
+            expect(result2).toEqual({
+                owner: 'team',
+                repo: 'project',
+                pullNumber: 456,
+                hostname: 'git.company.io',
+            });
+        });
+        it('should return null for invalid URLs', () => {
+            expect(parseGitHubPrUrl('not-a-url')).toBe(null);
+            expect(parseGitHubPrUrl('https://github.com/owner/repo/issues/123')).toBe(null);
+            expect(parseGitHubPrUrl('https://github.com/owner/repo')).toBe(null);
+            expect(parseGitHubPrUrl('https://github.com/owner/repo/pull/abc')).toBe(null);
+        });
+        it('should handle malformed URLs gracefully', () => {
+            expect(parseGitHubPrUrl('')).toBe(null);
+            expect(parseGitHubPrUrl('https://github.com')).toBe(null);
+            expect(parseGitHubPrUrl('https://github.com/owner')).toBe(null);
+            expect(parseGitHubPrUrl('https://github.com/owner/repo/pull')).toBe(null);
+        });
+    });
+});