difit 3.1.18 → 4.0.0

package/dist/server/server.test.js

@@ -59,6 +59,7 @@ vi.mock('./git-diff.js', () => {
             isEmpty: false,
         });
         getBlobContent = vi.fn().mockResolvedValue(Buffer.from('mock image data'));
+        getLineCount = vi.fn().mockResolvedValue(42);
         getGeneratedStatus = vi.fn().mockResolvedValue({
             isGenerated: true,
             source: 'content',
@@ -255,6 +256,74 @@ describe('Server Integration Tests', () => {
             expect(response.ok).toBe(true);
             expect(data).toHaveProperty('ignoreWhitespace', true);
         });
+        it('GET /api/diff returns comment import payload when configured', async () => {
+            const importedComments = [
+                {
+                    type: 'thread',
+                    filePath: 'test.js',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported comment',
+                },
+            ];
+            const importServer = await startServer({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: 9034,
+                commentImports: importedComments,
+            });
+            servers.push(importServer.server);
+            const response = await fetch(`http://localhost:${importServer.port}/api/diff`);
+            const data = (await response.json());
+            expect(response.ok).toBe(true);
+            expect(data.commentImports).toEqual(importedComments);
+            expect(data.commentImportId).toEqual(expect.any(String));
+        });
+        it('GET /api/diff returns clearComments together with comment import payload', async () => {
+            const importedComments = [
+                {
+                    type: 'thread',
+                    filePath: 'test.js',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported comment',
+                },
+            ];
+            const importServer = await startServer({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: 9037,
+                clearComments: true,
+                commentImports: importedComments,
+            });
+            servers.push(importServer.server);
+            const response = await fetch(`http://localhost:${importServer.port}/api/diff`);
+            const data = (await response.json());
+            expect(response.ok).toBe(true);
+            expect(data.clearComments).toBe(true);
+            expect(data.commentImports).toEqual(importedComments);
+            expect(data.commentImportId).toEqual(expect.any(String));
+        });
+        it('GET /api/diff omits comment import payload after revision changes', async () => {
+            const importedComments = [
+                {
+                    type: 'thread',
+                    filePath: 'test.js',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported comment',
+                },
+            ];
+            const importServer = await startServer({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: 9038,
+                commentImports: importedComments,
+            });
+            servers.push(importServer.server);
+            const response = await fetch(`http://localhost:${importServer.port}/api/diff?base=main&target=feature`);
+            const data = (await response.json());
+            expect(response.ok).toBe(true);
+            expect(data.commentImports).toBeUndefined();
+            expect(data.commentImportId).toBeUndefined();
+        });
         it('GET /api/generated-status/* returns generated status', async () => {
             const response = await fetch(`http://localhost:${port}/api/generated-status/src/query.ts?ref=HEAD`);
             const data = (await response.json());
@@ -329,6 +398,7 @@ describe('Server Integration Tests', () => {
             const response = await fetch(`http://localhost:${port}/api/comments-output`);
             const output = await response.text();
             expect(response.ok).toBe(true);
+            expect(response.headers.get('Content-Type')).toContain('text/plain');
             expect(output).toContain('Comments from review session');
             expect(output).toContain('test.js:L10');
             expect(output).toContain('First comment');
@@ -427,6 +497,17 @@ describe('Server Integration Tests', () => {
             // But the server should not crash
             expect([200, 404]).toContain(response.status);
         });
+        it('returns 404 for unknown paths in production mode', async () => {
+            process.env.NODE_ENV = 'production';
+            const result = await startServer({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: 9055,
+            });
+            servers.push(result.server);
+            const response = await fetch(`http://localhost:${result.port}/not-a-route`);
+            expect(response.status).toBe(404);
+        });
     });
     describe('Mode option handling', () => {
         it('accepts mode option in server configuration', async () => {
@@ -529,6 +610,39 @@ describe('Server Integration Tests', () => {
             expect(response.headers.get('Access-Control-Allow-Headers')).toBe('Origin, X-Requested-With, Content-Type, Accept');
         });
     });
+    describe('Line count API', () => {
+        let port;
+        beforeEach(async () => {
+            const result = await startServer({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: 9050,
+            });
+            servers.push(result.server);
+            port = result.port;
+        });
+        it('returns line counts for repository files', async () => {
+            const response = await fetch(`http://localhost:${port}/api/line-count/src%2Findex.ts?oldRef=HEAD~1&newRef=HEAD`);
+            const data = (await response.json());
+            expect(response.ok).toBe(true);
+            expect(data).toEqual({
+                oldLineCount: 42,
+                newLineCount: 42,
+            });
+        });
+        it('rejects paths outside repository', async () => {
+            const response = await fetch(`http://localhost:${port}/api/line-count/..%2Foutside.txt`);
+            const data = (await response.json());
+            expect(response.status).toBe(400);
+            expect(data).toHaveProperty('error', 'File path outside repository');
+        });
+        it('rejects oldPath values outside repository', async () => {
+            const response = await fetch(`http://localhost:${port}/api/line-count/src%2Findex.ts?oldRef=HEAD~1&oldPath=..%2Foutside.txt`);
+            const data = (await response.json());
+            expect(response.status).toBe(400);
+            expect(data).toHaveProperty('error', 'File path outside repository');
+        });
+    });
     describe('Blob API endpoints', () => {
         let port;
         beforeEach(async () => {
@@ -609,6 +723,12 @@ describe('Server Integration Tests', () => {
                 expect(response.ok).toBe(true);
             }
         });
+        it('rejects paths outside repository', async () => {
+            const response = await fetch(`http://localhost:${port}/api/blob/..%2Foutside.txt?ref=HEAD`);
+            const data = (await response.json());
+            expect(response.status).toBe(400);
+            expect(data).toHaveProperty('error', 'File path outside repository');
+        });
     });
     describe('Keep-alive option', () => {
         it('accepts keepAlive option without error', async () => {

package/dist/types/diff.d.ts

@@ -34,6 +34,18 @@ export interface ParsedDiff {
 export type DiffViewMode = 'split' | 'unified';
 export type LegacyDiffViewMode = 'side-by-side' | 'inline';
 export type DiffSide = 'old' | 'new';
+export type DiffLineRange = number | {
+    start: number;
+    end: number;
+};
+export interface DiffCommentPosition {
+    side: DiffSide;
+    line: DiffLineRange;
+}
+export interface DiffCommentCodeSnapshot {
+    content: string;
+    language?: string;
+}
 export interface DiffResponse {
     commit: string;
     files: DiffFile[];
@@ -47,6 +59,8 @@ export interface DiffResponse {
     requestedTargetCommitish?: string;
     clearComments?: boolean;
     repositoryId?: string;
+    commentImports?: CommentImport[];
+    commentImportId?: string;
 }
 export interface GeneratedStatusResponse {
     path: string;
@@ -69,38 +83,82 @@ export interface LineSelection {
     side: DiffSide;
     lineNumber: number;
 }
-export interface DiffComment {
+export interface LegacyDiffComment {
     id: string;
     filePath: string;
     body: string;
     author?: string;
     createdAt: string;
     updatedAt: string;
-    position: {
-        side: DiffSide;
-        line: number | {
-            start: number;
-            end: number;
-        };
-    };
-    codeSnapshot?: {
-        content: string;
-        language?: string;
-    };
+    position: DiffCommentPosition;
+    codeSnapshot?: DiffCommentCodeSnapshot;
+}
+export interface DiffCommentMessage {
+    id: string;
+    body: string;
+    author?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface DiffCommentThread {
+    id: string;
+    filePath: string;
+    createdAt: string;
+    updatedAt: string;
+    position: DiffCommentPosition;
+    codeSnapshot?: DiffCommentCodeSnapshot;
+    messages: DiffCommentMessage[];
+}
+interface CommentImportBase {
+    id?: string;
+    filePath: string;
+    position: DiffCommentPosition;
+    body: string;
+    author?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    codeSnapshot?: DiffCommentCodeSnapshot;
 }
+export interface ThreadCommentImport extends CommentImportBase {
+    type: 'thread';
+}
+export interface ReplyCommentImport extends CommentImportBase {
+    type: 'reply';
+}
+export type CommentImport = ThreadCommentImport | ReplyCommentImport;
 export interface ViewedFileRecord {
     filePath: string;
     viewedAt: string;
     diffContentHash: string;
 }
-export interface DiffContextStorage {
+export interface LegacyDiffContextStorage {
     version: 1;
     baseCommitish: string;
     targetCommitish: string;
     createdAt: string;
     lastModifiedAt: string;
-    comments: DiffComment[];
+    comments: LegacyDiffComment[];
+    viewedFiles: ViewedFileRecord[];
+}
+export interface DiffContextStorage {
+    version: 2;
+    baseCommitish: string;
+    targetCommitish: string;
+    createdAt: string;
+    lastModifiedAt: string;
+    threads: DiffCommentThread[];
     viewedFiles: ViewedFileRecord[];
+    appliedCommentImportIds: string[];
+}
+export interface CommentThread {
+    id: string;
+    file: string;
+    line: LineNumber;
+    side?: DiffSide;
+    createdAt: string;
+    updatedAt: string;
+    codeContent?: string;
+    messages: DiffCommentMessage[];
 }
 export interface RevisionOption {
     value: string;
@@ -140,3 +198,4 @@ export interface ExpandedRange {
 export interface ExpandedLine extends DiffLine {
     isExpanded?: boolean;
 }
+export {};

package/dist/utils/commentFormatting.d.ts

@@ -1,4 +1,6 @@
-import type { Comment } from '../types/diff';
+import type { Comment, CommentThread } from '../types/diff';
 export declare function formatCommentPrompt(file: string, line: number | number[], body: string, codeContent?: string): string;
 export declare function formatAllCommentsPrompt(comments: Comment[]): string;
-export declare function formatCommentsOutput(comments: Comment[]): string;
+export declare function formatCommentThreadPrompt(thread: CommentThread): string;
+export declare function formatAllCommentThreadsPrompt(threads: CommentThread[]): string;
+export declare function formatCommentsOutput(input: Comment[] | CommentThread[]): string;

package/dist/utils/commentFormatting.js

@@ -1,38 +1,56 @@
 import { hasSuggestionBlock, parseSuggestionBlocks } from './suggestionUtils.js';
-export function formatCommentPrompt(file, line, body, codeContent) {
-    const lineInfo = typeof line === 'number' ? `L${line}` : Array.isArray(line) ? `L${line[0]}-L${line[1]}` : '';
-    // Handle undefined or null file paths
-    const filePath = file || '<unknown file>';
-    // Check if body contains suggestion blocks
+function getLineInfo(line) {
+    return typeof line === 'number' ? `L${line}` : `L${line[0]}-L${line[1]}`;
+}
+function formatCommentContent(body, codeContent) {
     if (hasSuggestionBlock(body)) {
         const suggestions = parseSuggestionBlocks(body);
         if (suggestions.length > 0) {
-            let result = `${filePath}:${lineInfo}`;
-            // Walk through body preserving text between suggestion blocks
+            let result = '';
             let lastIndex = 0;
             for (const suggestion of suggestions) {
-                // Add text before this suggestion block
                 const textBefore = body.slice(lastIndex, suggestion.startIndex).trim();
                 if (textBefore) {
-                    result += `\n${textBefore}`;
+                    result += `${result ? '\n' : ''}${textBefore}`;
                 }
-                // Add structured ORIGINAL/SUGGESTED format
                 if (codeContent) {
-                    result += `\nORIGINAL:\n\`\`\`\n${codeContent}\n\`\`\``;
+                    result += `${result ? '\n' : ''}ORIGINAL:\n\`\`\`\n${codeContent}\n\`\`\``;
                 }
-                result += `\nSUGGESTED:\n\`\`\`\n${suggestion.suggestedCode}\n\`\`\``;
+                result += `${result ? '\n' : ''}SUGGESTED:\n\`\`\`\n${suggestion.suggestedCode}\n\`\`\``;
                 lastIndex = suggestion.endIndex;
             }
-            // Add remaining text after the last suggestion block
             const textAfter = body.slice(lastIndex).trim();
             if (textAfter) {
-                result += `\n${textAfter}`;
+                result += `${result ? '\n' : ''}${textAfter}`;
             }
             return result;
         }
     }
-    // Regular comment without suggestion
-    return `${filePath}:${lineInfo}\n${body}`;
+    return body;
+}
+function normalizeLegacyComment(comment) {
+    return {
+        id: comment.id,
+        file: comment.file,
+        line: comment.line,
+        side: comment.side,
+        createdAt: comment.timestamp,
+        updatedAt: comment.timestamp,
+        codeContent: comment.codeContent,
+        messages: [
+            {
+                id: comment.id,
+                body: comment.body,
+                author: comment.author,
+                createdAt: comment.timestamp,
+                updatedAt: comment.timestamp,
+            },
+        ],
+    };
+}
+export function formatCommentPrompt(file, line, body, codeContent) {
+    const filePath = file || '<unknown file>';
+    return `${filePath}:${getLineInfo(line)}\n${formatCommentContent(body, codeContent)}`;
 }
 export function formatAllCommentsPrompt(comments) {
     if (comments.length === 0)
@@ -40,13 +58,33 @@ export function formatAllCommentsPrompt(comments) {
     const prompts = comments.map((comment) => formatCommentPrompt(comment.file, comment.line, comment.body, comment.codeContent));
     return prompts.join('\n=====\n');
 }
-export function formatCommentsOutput(comments) {
-    const allPrompts = formatAllCommentsPrompt(comments);
+export function formatCommentThreadPrompt(thread) {
+    const sections = [`${thread.file || '<unknown file>'}:${getLineInfo(thread.line)}`];
+    thread.messages.forEach((message, index) => {
+        if (index === 0) {
+            sections.push(formatCommentContent(message.body, thread.codeContent));
+            return;
+        }
+        const replyIndex = index;
+        const authorLabel = message.author?.trim() || 'Unknown';
+        sections.push(`Reply ${replyIndex} (${authorLabel})`);
+        sections.push(formatCommentContent(message.body, thread.codeContent));
+    });
+    return sections.filter(Boolean).join('\n');
+}
+export function formatAllCommentThreadsPrompt(threads) {
+    if (threads.length === 0)
+        return '';
+    return threads.map((thread) => formatCommentThreadPrompt(thread)).join('\n=====\n');
+}
+export function formatCommentsOutput(input) {
+    const threads = input.map((item) => ('messages' in item ? item : normalizeLegacyComment(item)));
+    const allPrompts = formatAllCommentThreadsPrompt(threads);
     return [
         '\n📝 Comments from review session:',
         '='.repeat(50),
         allPrompts,
         '='.repeat(50),
-        `Total comments: ${comments.length}\n`,
+        `Total comments: ${threads.length}\n`,
     ].join('\n');
 }

package/dist/utils/commentImports.d.ts

@@ -0,0 +1,9 @@
+import type { CommentImport, DiffCommentThread } from '../types/diff.js';
+interface MergeCommentImportsResult {
+    threads: DiffCommentThread[];
+    warnings: string[];
+}
+export declare function parseCommentImportValue(value: string): CommentImport[];
+export declare function serializeCommentImports(commentImports: CommentImport[]): string;
+export declare function mergeCommentImports(existingThreads: DiffCommentThread[], commentImports: CommentImport[]): MergeCommentImportsResult;
+export {};

package/dist/utils/commentImports.js

@@ -0,0 +1,264 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isValidIsoTimestamp(value) {
+    return Number.isFinite(Date.parse(value));
+}
+function normalizeTimestamp(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string' || value.trim().length === 0 || !isValidIsoTimestamp(value)) {
+        throw new Error(`Invalid comment import field: ${fieldName}`);
+    }
+    return value;
+}
+function normalizeLineRange(value) {
+    if (typeof value === 'number' && Number.isInteger(value) && value > 0) {
+        return value;
+    }
+    if (!isRecord(value)) {
+        throw new Error('Invalid comment import field: position.line');
+    }
+    const start = value.start;
+    const end = value.end;
+    if (typeof start !== 'number' ||
+        typeof end !== 'number' ||
+        !Number.isInteger(start) ||
+        !Number.isInteger(end) ||
+        start <= 0 ||
+        end <= 0 ||
+        start > end) {
+        throw new Error('Invalid comment import field: position.line');
+    }
+    return { start, end };
+}
+function normalizePosition(value) {
+    if (!isRecord(value)) {
+        throw new Error('Invalid comment import field: position');
+    }
+    if (value.side !== 'old' && value.side !== 'new') {
+        throw new Error('Invalid comment import field: position.side');
+    }
+    return {
+        side: value.side,
+        line: normalizeLineRange(value.line),
+    };
+}
+function normalizeCodeSnapshot(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value) || typeof value.content !== 'string') {
+        throw new Error('Invalid comment import field: codeSnapshot');
+    }
+    if (value.language !== undefined && typeof value.language !== 'string') {
+        throw new Error('Invalid comment import field: codeSnapshot.language');
+    }
+    return {
+        content: value.content,
+        language: value.language,
+    };
+}
+function normalizeOptionalString(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid comment import field: ${fieldName}`);
+    }
+    return value;
+}
+function normalizeRequiredBody(value) {
+    if (typeof value !== 'string') {
+        throw new Error('Invalid comment import field: body');
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error('Invalid comment import field: body');
+    }
+    return trimmed;
+}
+function normalizeCommentImportEntry(value) {
+    if (!isRecord(value)) {
+        throw new Error('Comment import must be an object');
+    }
+    if (value.type !== 'thread' && value.type !== 'reply') {
+        throw new Error('Invalid comment import field: type');
+    }
+    if (typeof value.filePath !== 'string' || value.filePath.trim().length === 0) {
+        throw new Error('Invalid comment import field: filePath');
+    }
+    const createdAt = normalizeTimestamp(value.createdAt, 'createdAt');
+    const updatedAt = normalizeTimestamp(value.updatedAt, 'updatedAt');
+    const normalized = {
+        type: value.type,
+        id: normalizeOptionalString(value.id, 'id'),
+        filePath: value.filePath,
+        position: normalizePosition(value.position),
+        body: normalizeRequiredBody(value.body),
+        author: normalizeOptionalString(value.author, 'author'),
+        createdAt,
+        updatedAt,
+        codeSnapshot: normalizeCodeSnapshot(value.codeSnapshot),
+    };
+    return normalized;
+}
+function normalizeCommentImports(input) {
+    if (Array.isArray(input)) {
+        return input.map((entry) => normalizeCommentImportEntry(entry));
+    }
+    return [normalizeCommentImportEntry(input)];
+}
+export function parseCommentImportValue(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error('Invalid --comment JSON');
+    }
+    return normalizeCommentImports(parsed);
+}
+function getPositionKey(position) {
+    if (typeof position.line === 'number') {
+        return `${position.side}:${position.line}`;
+    }
+    return `${position.side}:${position.line.start}-${position.line.end}`;
+}
+function positionsMatch(left, right) {
+    return getPositionKey(left) === getPositionKey(right);
+}
+function normalizeAuthor(author) {
+    return author?.trim() || '';
+}
+function messageMatchesImport(message, commentImport, includeId = true) {
+    if (includeId && commentImport.id && message.id === commentImport.id) {
+        return true;
+    }
+    if (normalizeAuthor(message.author) !== normalizeAuthor(commentImport.author)) {
+        return false;
+    }
+    if (message.body !== commentImport.body) {
+        return false;
+    }
+    if (commentImport.createdAt && message.createdAt !== commentImport.createdAt) {
+        return false;
+    }
+    return true;
+}
+function rootThreadMatchesImport(thread, commentImport) {
+    if (commentImport.id && thread.id === commentImport.id) {
+        return true;
+    }
+    if (thread.filePath !== commentImport.filePath ||
+        !positionsMatch(thread.position, commentImport.position)) {
+        return false;
+    }
+    const rootMessage = thread.messages[0];
+    if (!rootMessage) {
+        return false;
+    }
+    return messageMatchesImport(rootMessage, commentImport, true);
+}
+function toThreadTimestamp(commentImport, now) {
+    const createdAt = commentImport.createdAt ?? now;
+    const updatedAt = commentImport.updatedAt ?? createdAt;
+    return { createdAt, updatedAt };
+}
+function maxIsoTimestamp(left, right) {
+    return left.localeCompare(right) >= 0 ? left : right;
+}
+function sortByNewestThread(left, right) {
+    return right.updatedAt.localeCompare(left.updatedAt);
+}
+function createImportedThread(commentImport, now) {
+    const { createdAt, updatedAt } = toThreadTimestamp(commentImport, now);
+    const threadId = commentImport.id ?? crypto.randomUUID();
+    return {
+        id: threadId,
+        filePath: commentImport.filePath,
+        createdAt,
+        updatedAt,
+        position: commentImport.position,
+        codeSnapshot: commentImport.codeSnapshot,
+        messages: [
+            {
+                id: commentImport.id ?? threadId,
+                body: commentImport.body,
+                author: commentImport.author,
+                createdAt,
+                updatedAt,
+            },
+        ],
+    };
+}
+function createImportedReply(commentImport, now) {
+    const { createdAt, updatedAt } = toThreadTimestamp(commentImport, now);
+    return {
+        id: commentImport.id ?? crypto.randomUUID(),
+        body: commentImport.body,
+        author: commentImport.author,
+        createdAt,
+        updatedAt,
+    };
+}
+function serializeLineRange(line) {
+    if (typeof line === 'number') {
+        return line;
+    }
+    return { start: line.start, end: line.end };
+}
+export function serializeCommentImports(commentImports) {
+    return JSON.stringify(commentImports.map((commentImport) => ({
+        type: commentImport.type,
+        id: commentImport.id,
+        filePath: commentImport.filePath,
+        position: {
+            side: commentImport.position.side,
+            line: serializeLineRange(commentImport.position.line),
+        },
+        body: commentImport.body,
+        author: commentImport.author,
+        createdAt: commentImport.createdAt,
+        updatedAt: commentImport.updatedAt,
+        codeSnapshot: commentImport.codeSnapshot
+            ? {
+                content: commentImport.codeSnapshot.content,
+                language: commentImport.codeSnapshot.language,
+            }
+            : undefined,
+    })));
+}
+export function mergeCommentImports(existingThreads, commentImports) {
+    const threads = [...existingThreads];
+    const warnings = [];
+    for (const commentImport of commentImports) {
+        const now = new Date().toISOString();
+        if (commentImport.type === 'thread') {
+            const hasDuplicate = threads.some((thread) => rootThreadMatchesImport(thread, commentImport));
+            if (hasDuplicate) {
+                continue;
+            }
+            threads.push(createImportedThread(commentImport, now));
+            continue;
+        }
+        const targetThreads = threads
+            .filter((thread) => thread.filePath === commentImport.filePath &&
+            positionsMatch(thread.position, commentImport.position))
+            .sort(sortByNewestThread);
+        const targetThread = targetThreads[0];
+        if (!targetThread) {
+            warnings.push(`Skipped reply import for ${commentImport.filePath}:${getPositionKey(commentImport.position)} because no matching thread was found.`);
+            continue;
+        }
+        const hasDuplicateReply = targetThread.messages.some((message) => messageMatchesImport(message, commentImport, true));
+        if (hasDuplicateReply) {
+            continue;
+        }
+        const importedReply = createImportedReply(commentImport, now);
+        targetThread.messages = [...targetThread.messages, importedReply];
+        targetThread.updatedAt = maxIsoTimestamp(targetThread.updatedAt, importedReply.updatedAt);
+    }
+    return { threads, warnings };
+}

package/dist/utils/commentImports.test.d.ts

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