feat(multibuffer): fast server-side raw diff with client-side unified diff parser & DiffCode

Author: vipmax

anycode-backend/src/git.rs

@@ -1128,6 +1128,74 @@ impl GitManager {
         })
     }
 
+    fn diff_to_patch_string(diff: &mut git2::Diff) -> Result<String> {
+        let mut patch_bytes = Vec::new();
+        diff.print(git2::DiffFormat::Patch, |_delta, _hunk, line| {
+            let origin = line.origin();
+            match origin {
+                '+' | '-' | ' ' => {
+                    patch_bytes.push(origin as u8);
+                    patch_bytes.extend_from_slice(line.content());
+                }
+                _ => {
+                    patch_bytes.extend_from_slice(line.content());
+                }
+            }
+            true
+        })?;
+        Ok(String::from_utf8_lossy(&patch_bytes).to_string())
+    }
+
+    /// Return raw unified diff output for the working directory / staged changes using in-memory libgit2.
+    pub fn raw_diff(&self, staged: Option<bool>) -> Result<String> {
+        let repo = self.repo()?;
+        let mut diff_opts = DiffOptions::new();
+        let mut find_opts = DiffFindOptions::new();
+        find_opts.renames(true);
+
+        let mut diff = match staged {
+            Some(true) => {
+                let head_tree = repo.head().ok().and_then(|h| h.peel_to_tree().ok());
+                let mut d = repo.diff_tree_to_index(head_tree.as_ref(), None, Some(&mut diff_opts))?;
+                d.find_similar(Some(&mut find_opts))?;
+                d
+            }
+            Some(false) => {
+                let mut d = repo.diff_index_to_workdir(None, Some(&mut diff_opts))?;
+                d.find_similar(Some(&mut find_opts))?;
+                d
+            }
+            None => {
+                let head_tree = repo.head().ok().and_then(|h| h.peel_to_tree().ok());
+                let mut d = repo.diff_tree_to_workdir_with_index(head_tree.as_ref(), Some(&mut diff_opts))?;
+                d.find_similar(Some(&mut find_opts))?;
+                d
+            }
+        };
+
+        Self::diff_to_patch_string(&mut diff)
+    }
+
+    /// Return raw unified diff output for a specific commit hash using in-memory libgit2.
+    pub fn raw_commit_diff(&self, hash: &str) -> Result<String> {
+        let repo = self.repo()?;
+        let commit = repo.find_commit(git2::Oid::from_str(hash.trim())?)?;
+        let new_tree = commit.tree()?;
+        let old_tree = if commit.parent_count() > 0 {
+            Some(commit.parent(0)?.tree()?)
+        } else {
+            None
+        };
+        let mut diff_opts = DiffOptions::new();
+        let mut find_opts = DiffFindOptions::new();
+        find_opts.renames(true);
+
+        let mut diff = repo.diff_tree_to_tree(old_tree.as_ref(), Some(&new_tree), Some(&mut diff_opts))?;
+        diff.find_similar(Some(&mut find_opts))?;
+
+        Self::diff_to_patch_string(&mut diff)
+    }
+
     /// Commit currently staged index entries (like `git commit`)
     pub fn commit(&self, message: &str) -> Result<()> {
         let repo = self.repo()?;

anycode-backend/src/handlers/connection_handler.rs

@@ -66,6 +66,8 @@ pub async fn handle_connect(socket: SocketRef, _state: State<AppState>) {
     socket.on("git:revert", handle_git_revert);
     socket.on("git:stage", handle_git_stage);
     socket.on("git:unstage", handle_git_unstage);
+    socket.on("git:diff-raw", handle_git_diff_raw);
+    socket.on("git:commit-diff-raw", handle_git_commit_diff_raw);
 
     socket.on("theme:list", handle_theme_list);
     socket.on("theme:get", handle_theme_get);

anycode-backend/src/handlers/git_handler.rs

@@ -416,6 +416,43 @@ pub async fn handle_git_unstage(
     send_response(ack, result);
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+pub struct GitDiffRawRequest {
+    #[serde(default)]
+    pub staged: Option<bool>,
+}
+
+pub async fn handle_git_diff_raw(
+    Data(request): Data<GitDiffRawRequest>,
+    ack: AckSender,
+    state: State<AppState>,
+) {
+    info!("Received git:diff-raw: staged={:?}", request.staged);
+    let result = {
+        let git = state.git_manager.lock().await;
+        git.raw_diff(request.staged).map(|diff| json!({ "diff": diff }))
+    };
+    send_response(ack, result);
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct GitCommitDiffRawRequest {
+    pub hash: String,
+}
+
+pub async fn handle_git_commit_diff_raw(
+    Data(request): Data<GitCommitDiffRawRequest>,
+    ack: AckSender,
+    state: State<AppState>,
+) {
+    info!("Received git:commit-diff-raw: hash={}", request.hash);
+    let result = {
+        let git = state.git_manager.lock().await;
+        git.raw_commit_diff(&request.hash).map(|diff| json!({ "diff": diff }))
+    };
+    send_response(ack, result);
+}
+
 pub async fn is_file_tracked(abs_path: &str, state: &AppState) -> bool {
     let git = state.git_manager.lock().await;
     match git.file_original(abs_path) {

anycode-backend/src/tests/git.rs

@@ -604,3 +604,53 @@ fn benchmark_status_real() {
         "Real custom version must be faster than CLI!"
     );
 }
+
+#[test]
+fn test_raw_diff_and_commit_diff() {
+    let temp_dir = tempfile::tempdir().unwrap();
+    let repo_dir = temp_dir.path().to_path_buf();
+    let repo = git2::Repository::init(&repo_dir).unwrap();
+    let manager = GitManager::new(repo_dir.clone());
+
+    // Create file1 and commit
+    let file1_path = repo_dir.join("file1.txt");
+    std::fs::write(&file1_path, "hello\nworld\n").unwrap();
+    let mut index = repo.index().unwrap();
+    index.add_path(std::path::Path::new("file1.txt")).unwrap();
+    index.write().unwrap();
+    let tree_id = index.write_tree().unwrap();
+    let tree = repo.find_tree(tree_id).unwrap();
+    let sig = git2::Signature::now("Tester", "test@test.com").unwrap();
+    let commit1_oid = repo.commit(Some("HEAD"), &sig, &sig, "Initial commit", &tree, &[]).unwrap();
+    let commit1_hash = commit1_oid.to_string();
+
+    // Modify file1
+    std::fs::write(&file1_path, "hello\nbrave\nnew\nworld\n").unwrap();
+
+    // Test unstaged raw diff
+    let raw_unstaged = manager.raw_diff(Some(false)).unwrap();
+    assert!(raw_unstaged.contains("diff --git a/file1.txt b/file1.txt"));
+    assert!(raw_unstaged.contains("+brave"));
+    assert!(raw_unstaged.contains("+new"));
+
+    // Stage and test staged raw diff
+    manager.stage("file1.txt").unwrap();
+    let raw_staged = manager.raw_diff(Some(true)).unwrap();
+    assert!(raw_staged.contains("diff --git a/file1.txt b/file1.txt"));
+    assert!(raw_staged.contains("+brave"));
+
+    // Commit change
+    manager.commit("Second commit").unwrap();
+    let head_commit = repo.head().unwrap().peel_to_commit().unwrap();
+    let commit2_hash = head_commit.id().to_string();
+
+    // Test raw commit diff for second commit
+    let raw_commit = manager.raw_commit_diff(&commit2_hash).unwrap();
+    assert!(raw_commit.contains("diff --git a/file1.txt b/file1.txt"));
+    assert!(raw_commit.contains("+brave"));
+
+    // Test raw commit diff for initial root commit
+    let raw_root_commit = manager.raw_commit_diff(&commit1_hash).unwrap();
+    assert!(raw_root_commit.contains("diff --git a/file1.txt b/file1.txt") || raw_root_commit.contains("file1.txt"));
+    assert!(raw_root_commit.contains("+hello"));
+}

anycode-base/src/diffCode.ts

@@ -0,0 +1,166 @@
+import { HighlighedNode, Position } from './code';
+import { DiffModel } from './diff';
+import { ParsedDiffFile } from './diffParser';
+
+export class DiffCode {
+    public readonly path: string;
+    public readonly filename: string;
+    public readonly language: string;
+    public readonly lines: string[];
+    public readonly displayLineNumbers: (number | undefined)[];
+    public readonly diffs: DiffModel;
+    public readonly added: number;
+    public readonly removed: number;
+    public readonly status: 'modified' | 'added' | 'deleted' | 'renamed';
+    public readonly oldPath?: string;
+
+    private lineOffsets: number[] = [];
+    private totalLength: number = 0;
+    private contentCache: string | null = null;
+
+    constructor(
+        path: string,
+        lines: string[],
+        displayLineNumbers: (number | undefined)[] = [],
+        diffs: DiffModel = DiffModel.empty(),
+        added: number = 0,
+        removed: number = 0,
+        status: 'modified' | 'added' | 'deleted' | 'renamed' = 'modified',
+        oldPath?: string
+    ) {
+        this.path = path;
+        this.filename = path.split('/').pop() || path;
+        this.language = this.detectLanguage(path);
+        this.lines = lines;
+        this.displayLineNumbers = displayLineNumbers;
+        this.diffs = diffs;
+        this.added = added;
+        this.removed = removed;
+        this.status = status;
+        this.oldPath = oldPath;
+
+        this.computeOffsets();
+    }
+
+    public static fromParsedFile(file: ParsedDiffFile, isOriginal: boolean = false): DiffCode {
+        const lines = isOriginal ? file.oldLines : file.newLines;
+        const lineNumbers = isOriginal ? file.oldLineNumbers : file.newLineNumbers;
+        return new DiffCode(
+            file.path,
+            lines,
+            lineNumbers,
+            file.diffs,
+            file.added,
+            file.removed,
+            file.status,
+            file.oldPath
+        );
+    }
+
+    private detectLanguage(filePath: string): string {
+        const ext = filePath.split('.').pop()?.toLowerCase();
+        switch (ext) {
+            case 'ts':
+            case 'tsx':
+                return 'typescript';
+            case 'js':
+            case 'jsx':
+                return 'javascript';
+            case 'rs':
+                return 'rust';
+            case 'py':
+                return 'python';
+            case 'json':
+                return 'json';
+            case 'css':
+                return 'css';
+            case 'html':
+                return 'html';
+            case 'md':
+                return 'markdown';
+            default:
+                return 'plaintext';
+        }
+    }
+
+    private computeOffsets(): void {
+        this.lineOffsets = [];
+        let currentOffset = 0;
+        for (let i = 0; i < this.lines.length; i++) {
+            this.lineOffsets.push(currentOffset);
+            currentOffset += this.lines[i].length + 1; // +1 for newline
+        }
+        this.totalLength = Math.max(0, currentOffset > 0 ? currentOffset - 1 : 0);
+    }
+
+    public getContent(): string {
+        if (this.contentCache === null) {
+            this.contentCache = this.lines.join('\n');
+        }
+        return this.contentCache;
+    }
+
+    public getContentLength(): number {
+        return this.totalLength;
+    }
+
+    public getLines(): string[] {
+        return this.lines;
+    }
+
+    public line(index: number): string {
+        return this.lines[index] ?? '';
+    }
+
+    public linesLength(): number {
+        return this.lines.length;
+    }
+
+    public getPosition(offset: number): Position {
+        if (this.lines.length === 0) return { line: 0, column: 0 };
+        if (offset <= 0) return { line: 0, column: 0 };
+
+        let low = 0;
+        let high = this.lineOffsets.length - 1;
+        let line = 0;
+
+        while (low <= high) {
+            const mid = (low + high) >> 1;
+            if (this.lineOffsets[mid] <= offset) {
+                line = mid;
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+
+        const lineStart = this.lineOffsets[line] ?? 0;
+        const column = Math.max(0, offset - lineStart);
+        return { line, column };
+    }
+
+    public getOffset(line: number, column: number): number {
+        if (line < 0) return 0;
+        if (line >= this.lines.length) return this.totalLength;
+        const lineStart = this.lineOffsets[line] ?? 0;
+        const lineLen = this.lines[line]?.length ?? 0;
+        return lineStart + Math.min(Math.max(0, column), lineLen);
+    }
+
+    public getIntervalContent2(start: number, end: number): string {
+        const content = this.getContent();
+        return content.substring(Math.max(0, start), Math.min(content.length, end));
+    }
+
+    public getLineNodes(_index: number): HighlighedNode[] {
+        return [];
+    }
+
+    public getLineBinaryTokens(_index: number): Uint32Array | undefined {
+        return undefined;
+    }
+
+    public getDiffs(): DiffModel {
+        return this.diffs;
+    }
+}