difit 3.1.18 → 4.0.1

package/dist/server/server.js

@@ -7,6 +7,7 @@ import open from 'open';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { formatCommentsOutput } from '../utils/commentFormatting.js';
+import { serializeCommentImports } from '../utils/commentImports.js';
 import { normalizeDiffViewMode } from '../utils/diffMode.js';
 import { resolveEditorOption } from '../utils/editorOptions.js';
 import { getFileExtension } from '../utils/fileUtils.js';
@@ -17,6 +18,12 @@ export async function startServer(options) {
     const app = express();
     const repositoryPath = resolve(options.repoPath ?? process.cwd());
     const repositoryId = createHash('sha256').update(repositoryPath).digest('hex');
+    const initialCommentImports = options.commentImports || [];
+    const initialBaseCommitish = options.baseCommitish ?? '';
+    const initialTargetCommitish = options.targetCommitish ?? '';
+    const commentImportId = initialCommentImports.length > 0
+        ? createHash('sha256').update(serializeCommentImports(initialCommentImports)).digest('hex')
+        : undefined;
     const parser = new GitDiffParser(repositoryPath);
     const fileWatcher = new FileWatcherService();
     const generatedStatusCache = new Map();
@@ -44,7 +51,7 @@ export async function startServer(options) {
         diffDataCache = parser.parseStdinDiff(options.stdinDiff);
     }
     else {
-        diffDataCache = await parser.parseDiff(options.targetCommitish ?? '', options.baseCommitish ?? '', currentIgnoreWhitespace);
+        diffDataCache = await parser.parseDiff(options.targetCommitish ?? '', options.baseCommitish ?? '', currentIgnoreWhitespace, options.contextLines);
     }
     // Function to invalidate cache when file changes are detected
     const invalidateCache = () => {
@@ -55,10 +62,28 @@ export async function startServer(options) {
     // Track current revisions for cache invalidation
     let currentBaseCommitish = options.baseCommitish ?? '';
     let currentTargetCommitish = options.targetCommitish ?? '';
+    function parseRepositoryRelativePath(filepath) {
+        if (typeof filepath !== 'string' || filepath.length === 0) {
+            return { ok: false, error: 'Invalid file path' };
+        }
+        const normalizedFilepath = filepath.replace(/\\/g, '/');
+        const hasParentTraversal = normalizedFilepath.split('/').some((segment) => segment === '..');
+        if (isAbsolute(filepath) || normalizedFilepath.startsWith('/') || hasParentTraversal) {
+            return { ok: false, error: 'File path outside repository' };
+        }
+        const resolvedPath = resolve(repositoryPath, normalizedFilepath);
+        if (resolvedPath !== repositoryPath && !resolvedPath.startsWith(`${repositoryPath}${sep}`)) {
+            return { ok: false, error: 'File path outside repository' };
+        }
+        return { ok: true, path: normalizedFilepath };
+    }
     app.get('/api/diff', async (req, res) => {
         const ignoreWhitespace = req.query.ignoreWhitespace === 'true';
         const requestedBase = req.query.base || options.baseCommitish || '';
         const requestedTarget = req.query.target || options.targetCommitish || '';
+        const shouldIncludeCommentImports = initialCommentImports.length > 0 &&
+            (Boolean(options.stdinDiff) ||
+                (requestedBase === initialBaseCommitish && requestedTarget === initialTargetCommitish));
         // Check if revisions or whitespace setting changed
         const revisionsChanged = requestedBase !== currentBaseCommitish || requestedTarget !== currentTargetCommitish;
         const whitespaceChanged = ignoreWhitespace !== currentIgnoreWhitespace;
@@ -67,7 +92,7 @@ export async function startServer(options) {
             currentIgnoreWhitespace = ignoreWhitespace;
             currentBaseCommitish = requestedBase;
             currentTargetCommitish = requestedTarget;
-            diffDataCache = await parser.parseDiff(requestedTarget, requestedBase, ignoreWhitespace);
+            diffDataCache = await parser.parseDiff(requestedTarget, requestedBase, ignoreWhitespace, options.contextLines);
             generatedStatusCache.clear();
         }
         // Resolve symbolic refs like HEAD/HEAD^ to actual hashes for the UI
@@ -106,6 +131,8 @@ export async function startServer(options) {
             requestedTargetCommitish,
             clearComments: options.clearComments,
             repositoryId,
+            commentImports: shouldIncludeCommentImports ? initialCommentImports : undefined,
+            commentImportId: shouldIncludeCommentImports ? commentImportId : undefined,
         });
     });
     app.get(/^\/api\/generated-status\/(.*)$/, async (req, res) => {
@@ -114,22 +141,12 @@ export async function startServer(options) {
             return;
         }
         try {
-            const filepath = req.params[0];
-            if (typeof filepath !== 'string' || filepath.length === 0) {
-                res.status(400).json({ error: 'Invalid file path' });
-                return;
-            }
-            const normalizedFilepath = filepath.replace(/\\/g, '/');
-            const hasParentTraversal = normalizedFilepath.split('/').some((segment) => segment === '..');
-            if (isAbsolute(filepath) || normalizedFilepath.startsWith('/') || hasParentTraversal) {
-                res.status(400).json({ error: 'File path outside repository' });
-                return;
-            }
-            const resolvedPath = resolve(repositoryPath, normalizedFilepath);
-            if (resolvedPath !== repositoryPath && !resolvedPath.startsWith(`${repositoryPath}${sep}`)) {
-                res.status(400).json({ error: 'File path outside repository' });
+            const filepathResult = parseRepositoryRelativePath(req.params[0]);
+            if (!filepathResult.ok) {
+                res.status(400).json({ error: filepathResult.error });
                 return;
             }
+            const normalizedFilepath = filepathResult.path;
             const ref = req.query.ref || currentTargetCommitish || 'HEAD';
             const cacheKey = `${ref}:${normalizedFilepath}`;
             const now = Date.now();
@@ -162,7 +179,7 @@ export async function startServer(options) {
             return;
         }
         try {
-            const { branches, commits, resolvedBase, resolvedTarget } = await parser.getRevisionOptions(currentBaseCommitish, currentTargetCommitish);
+            const { branches, commits, originDefaultBranch, resolvedBase, resolvedTarget } = await parser.getRevisionOptions(currentBaseCommitish, currentTargetCommitish);
             const response = {
                 specialOptions: [
                     { value: '.', label: 'All Uncommitted Changes' },
@@ -171,6 +188,7 @@ export async function startServer(options) {
                 ],
                 branches,
                 commits,
+                originDefaultBranch,
                 resolvedBase,
                 resolvedTarget,
             };
@@ -187,10 +205,22 @@ export async function startServer(options) {
                 res.status(404).json({ error: 'Line count not available for stdin diff' });
                 return;
             }
-            const filepath = req.params[0];
+            const filepathResult = parseRepositoryRelativePath(req.params[0]);
+            if (!filepathResult.ok) {
+                res.status(400).json({ error: filepathResult.error });
+                return;
+            }
+            const filepath = filepathResult.path;
             const oldRef = req.query.oldRef;
+            const oldPathResult = req.query.oldPath
+                ? parseRepositoryRelativePath(req.query.oldPath)
+                : { ok: true, path: filepath };
+            if (!oldPathResult.ok) {
+                res.status(400).json({ error: oldPathResult.error });
+                return;
+            }
             const newRef = req.query.newRef;
-            const oldPath = req.query.oldPath || filepath;
+            const oldPath = oldPathResult.path;
             const result = {};
             if (oldRef) {
                 try {
@@ -222,7 +252,12 @@ export async function startServer(options) {
                 res.status(404).json({ error: 'Blob content not available for stdin diff' });
                 return;
             }
-            const filepath = req.params[0];
+            const filepathResult = parseRepositoryRelativePath(req.params[0]);
+            if (!filepathResult.ok) {
+                res.status(400).json({ error: filepathResult.error });
+                return;
+            }
+            const filepath = filepathResult.path;
             const ref = req.query.ref || 'HEAD';
             const blob = await parser.getBlobContent(filepath, ref);
             // Determine content type based on file extension
@@ -254,18 +289,59 @@ export async function startServer(options) {
             res.status(404).json({ error: 'File not found' });
         }
     });
-    // Store comments for final output
-    let finalComments = [];
-    // Parse comments from request body (handles both JSON and text/plain)
+    let finalThreads = [];
+    function normalizeComment(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,
+                },
+            ],
+        };
+    }
+    function normalizeThreadPayload(thread) {
+        if ('file' in thread && 'line' in thread) {
+            return thread;
+        }
+        return {
+            id: thread.id,
+            file: thread.filePath,
+            line: typeof thread.position.line === 'number'
+                ? thread.position.line
+                : [thread.position.line.start, thread.position.line.end],
+            side: thread.position.side,
+            createdAt: thread.createdAt,
+            updatedAt: thread.updatedAt,
+            codeContent: thread.codeSnapshot?.content,
+            messages: thread.messages,
+        };
+    }
     function parseCommentsPayload(body) {
         const payload = typeof body === 'string'
             ? JSON.parse(body)
             : body;
-        return payload.comments || [];
+        if (Array.isArray(payload.threads)) {
+            return payload.threads.map(normalizeThreadPayload);
+        }
+        if (Array.isArray(payload.comments)) {
+            return payload.comments.map(normalizeComment);
+        }
+        return [];
     }
     app.post('/api/comments', (req, res) => {
         try {
-            finalComments = parseCommentsPayload(req.body);
+            finalThreads = parseCommentsPayload(req.body);
             res.json({ success: true });
         }
         catch (error) {
@@ -274,8 +350,9 @@ export async function startServer(options) {
         }
     });
     app.get('/api/comments-output', (_req, res) => {
-        if (finalComments.length > 0) {
-            const output = formatCommentsOutput(finalComments);
+        res.type('text/plain');
+        if (finalThreads.length > 0) {
+            const output = formatCommentsOutput(finalThreads);
             res.send(output);
         }
         else {
@@ -292,12 +369,12 @@ export async function startServer(options) {
             res.status(400).json({ error: 'Invalid request payload' });
             return;
         }
-        const repoRoot = resolve(options.repoPath ?? process.cwd());
-        const resolvedPath = resolve(repoRoot, filePath);
-        if (resolvedPath !== repoRoot && !resolvedPath.startsWith(`${repoRoot}${sep}`)) {
-            res.status(400).json({ error: 'File path outside repository' });
+        const filepathResult = parseRepositoryRelativePath(filePath);
+        if (!filepathResult.ok) {
+            res.status(400).json({ error: filepathResult.error });
             return;
         }
+        const resolvedPath = resolve(repositoryPath, filepathResult.path);
         const editorInput = typeof editor === 'string' ? editor : (process.env.DIFIT_EDITOR ?? process.env.EDITOR);
         const resolvedEditor = resolveEditorOption(editorInput);
         if (resolvedEditor.protocol === null) {
@@ -324,7 +401,7 @@ export async function startServer(options) {
             else {
                 args.push(resolvedPath);
             }
-            args.push(repoRoot);
+            args.push(repositoryPath);
             return await new Promise((resolvePromise) => {
                 const child = spawn(resolvedEditor.cliCommand, args, { stdio: 'ignore', detached: true });
                 child.once('error', (error) => {
@@ -357,8 +434,8 @@ export async function startServer(options) {
     });
     // Function to output comments when server shuts down
     function outputFinalComments() {
-        if (finalComments.length > 0) {
-            console.log(formatCommentsOutput(finalComments));
+        if (finalThreads.length > 0) {
+            console.log(formatCommentsOutput(finalThreads));
         }
     }
     // SSE endpoint for file watching
@@ -413,9 +490,6 @@ export async function startServer(options) {
         // Find client files relative to the CLI executable location
         const distPath = join(__dirname, '..', 'client');
         app.use(express.static(distPath));
-        app.get('/{*splat}', (_req, res) => {
-            res.sendFile(join(distPath, 'index.html'));
-        });
     }
     else {
         app.get('/', (_req, res) => {

package/dist/server/server.test.js

@@ -5,6 +5,7 @@ import { startServer } from './server.js';
 // Add fetch polyfill for Node.js test environment
 const { fetch } = await import('undici');
 globalThis.fetch = fetch;
+const parserInstances = vi.hoisted(() => []);
 // Helper function to get available port
 async function getAvailablePort(preferredPort) {
     let port = preferredPort;
@@ -25,6 +26,9 @@ async function getAvailablePort(preferredPort) {
 // Mock GitDiffParser
 vi.mock('./git-diff.js', () => {
     class GitDiffParserMock {
+        constructor() {
+            parserInstances.push(this);
+        }
         validateCommit = vi.fn().mockResolvedValue(true);
         parseDiff = vi.fn().mockResolvedValue({
             targetCommit: 'abc123',
@@ -59,6 +63,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',
@@ -67,6 +72,7 @@ vi.mock('./git-diff.js', () => {
         getRevisionOptions = vi.fn().mockResolvedValue({
             branches: [{ name: 'main', current: true }],
             commits: [{ hash: 'abc1234', shortHash: 'abc1234', message: 'Test commit' }],
+            originDefaultBranch: 'origin/main',
             resolvedBase: 'abc1234',
             resolvedTarget: 'def5678',
         });
@@ -166,6 +172,7 @@ describe('Server Integration Tests', () => {
         // Mock process.exit to prevent tests from actually exiting
         originalProcessExit = process.exit;
         process.exit = vi.fn();
+        parserInstances.length = 0;
     });
     afterEach(async () => {
         // Restore process.exit
@@ -225,6 +232,17 @@ describe('Server Integration Tests', () => {
             servers.push(result.server);
             expect(result.url).toContain('http://localhost:'); // Display host conversion
         });
+        it('passes context lines to the initial diff load', async () => {
+            const result = await startServer({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: 9025,
+                contextLines: 4,
+            });
+            servers.push(result.server);
+            const parser = parserInstances.at(-1);
+            expect(parser?.parseDiff).toHaveBeenCalledWith('HEAD', 'HEAD^', false, 4);
+        });
     });
     describe('API endpoints', () => {
         let port;
@@ -255,6 +273,88 @@ describe('Server Integration Tests', () => {
             expect(response.ok).toBe(true);
             expect(data).toHaveProperty('ignoreWhitespace', true);
         });
+        it('GET /api/diff preserves context lines when recalculating revisions', async () => {
+            const result = await startServer({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: 9031,
+                contextLines: 2,
+            });
+            servers.push(result.server);
+            const parser = parserInstances.at(-1);
+            parser?.parseDiff.mockClear();
+            const response = await fetch(`http://localhost:${result.port}/api/diff?base=main&target=feature&ignoreWhitespace=true`);
+            expect(response.ok).toBe(true);
+            expect(parser?.parseDiff).toHaveBeenCalledWith('feature', 'main', true, 2);
+        });
+        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 +429,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 +528,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 () => {
@@ -484,6 +596,7 @@ describe('Server Integration Tests', () => {
             expect(data.commits).toEqual([
                 { hash: 'abc1234', shortHash: 'abc1234', message: 'Test commit' },
             ]);
+            expect(data.originDefaultBranch).toBe('origin/main');
             expect(data.resolvedBase).toBe('abc1234');
             expect(data.resolvedTarget).toBe('def5678');
         });
@@ -529,6 +642,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 +755,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/tui/App.d.ts

@@ -4,6 +4,7 @@ interface AppProps {
     baseCommitish: string;
     mode?: string;
     repoPath?: string;
+    contextLines?: number;
 }
 declare const App: React.FC<AppProps>;
 export default App;

package/dist/tui/App.js

@@ -6,7 +6,7 @@ import DiffViewer from './components/DiffViewer.js';
 import FileList from './components/FileList.js';
 import SideBySideDiffViewer from './components/SideBySideDiffViewer.js';
 import StatusBar from './components/StatusBar.js';
-const App = ({ targetCommitish, baseCommitish, mode, repoPath }) => {
+const App = ({ targetCommitish, baseCommitish, mode, repoPath, contextLines, }) => {
     const [files, setFiles] = useState([]);
     const [selectedFileIndex, setSelectedFileIndex] = useState(0);
     const [loading, setLoading] = useState(true);
@@ -17,7 +17,7 @@ const App = ({ targetCommitish, baseCommitish, mode, repoPath }) => {
         setLoading(true);
         setError(null);
         try {
-            const fileDiffs = await loadGitDiff(targetCommitish, baseCommitish, repoPath);
+            const fileDiffs = await loadGitDiff(targetCommitish, baseCommitish, repoPath, contextLines);
             setFiles(fileDiffs);
             setLoading(false);
         }

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;
@@ -119,6 +177,7 @@ export interface RevisionsResponse {
     specialOptions: RevisionOption[];
     branches: BranchInfo[];
     commits: CommitInfo[];
+    originDefaultBranch?: string;
     resolvedBase?: string;
     resolvedTarget?: string;
 }
@@ -140,3 +199,4 @@ export interface ExpandedRange {
 export interface ExpandedLine extends DiffLine {
     isExpanded?: boolean;
 }
+export {};