feat(git): add Changes panel with full commit/push workflow

Add a new Source Control-like panel for managing Git changes:

- Add ChangesPanel component with file list, commit input, and push button
- Add ChangesPanel.css with VS Code-inspired styling
- Add Git branch icon to Icons collection
- Add leftPanelMode state for switching between files/search/changes views
- Implement fetchGitStatus() to get changed files and current branch
- Implement handleOpenChangedFile() with diff mode support
- Implement handleGitCommit() for staging and committing selected files
- Implement handleGitPush() for pushing to remote
- Refactor left panel rendering to use switch statement
- Update toolbar with mode toggle buttons

Author: vipmax

.gitignore

@@ -1,6 +1,7 @@
 target
 node_modules
 .DS_Store
+.anycode
 *copy*.ts
 anycode/dist
 anycode-base/dist

anycode-backend/src/app_state.rs

@@ -48,6 +48,25 @@ macro_rules! error_ack {
     }};
 }
 
+/// Helper: send response based on Result
+/// Used with _impl pattern: handler calls send_response(ack, some_impl())
+/// where some_impl() returns anyhow::Result<Value> and can use ? operator with .context()
+pub fn send_response(ack: socketioxide::extract::AckSender, result: anyhow::Result<serde_json::Value>) {
+    use serde_json::json;
+    match result {
+        Ok(data) => {
+            let mut response = data;
+            if let Some(obj) = response.as_object_mut() {
+                obj.insert("success".to_string(), json!(true));
+            }
+            ack.send(&response).ok();
+        }
+        Err(e) => {
+            ack.send(&json!({ "success": false, "error": format!("{:#}", e) })).ok();
+        }
+    }
+}
+
 pub fn get_or_create_code<'a>(
     f2c: &'a mut HashMap<String, Code>,
     path: &str,

anycode-backend/src/handlers/git_handler.rs

@@ -0,0 +1,207 @@
+use serde_json::{json, Value};
+use socketioxide::extract::{AckSender, Data, State};
+use tracing::info;
+use crate::app_state::{AppState, send_response};
+use serde::{Deserialize, Serialize};
+use git2::{Repository, Status, StatusOptions};
+use std::path::Path;
+use anyhow::{Context, Result};
+
+#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum FileStatus {
+    Modified, Added, Deleted, Renamed,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct GitFileStatus {
+    pub path: String,
+    pub status: FileStatus,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct GitFileOriginalRequest {
+    pub path: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct GitCommitRequest {
+    pub files: Vec<String>,
+    pub message: String,
+}
+
+fn git_status_impl() -> Result<Value> {
+    let workdir = crate::utils::current_dir();
+    
+    let repo = Repository::discover(&workdir)?;
+
+    let branch = repo.head()
+        .map(|h| h.shorthand().unwrap_or("HEAD").to_string())
+        .unwrap_or_else(|_| "HEAD".to_string());
+
+    let mut opts = StatusOptions::new();
+    opts.include_untracked(true)
+        .recurse_untracked_dirs(true)
+        .include_ignored(false);
+
+    let statuses = repo.statuses(Some(&mut opts))?;
+
+    let mut files: Vec<GitFileStatus> = Vec::new();
+
+    for entry in statuses.iter() {
+        let path = entry.path().unwrap_or("").to_string();
+        let status = entry.status();
+
+        let file_status = if status.contains(Status::WT_NEW) || status.contains(Status::INDEX_NEW) {
+            FileStatus::Added
+        } else if status.contains(Status::WT_DELETED) || status.contains(Status::INDEX_DELETED) {
+            FileStatus::Deleted
+        } else if status.contains(Status::WT_MODIFIED) || status.contains(Status::INDEX_MODIFIED) {
+            FileStatus::Modified
+        } else if status.contains(Status::WT_RENAMED) || status.contains(Status::INDEX_RENAMED) {
+            FileStatus::Renamed
+        } else {
+            continue;
+        };
+
+        files.push(GitFileStatus { 
+            path, status: file_status 
+        });
+    }
+
+    info!("Git status: {} files changed on branch {}", files.len(), branch);
+
+    Ok(json!({ "files": files, "branch": branch }))
+}
+
+pub async fn handle_git_status(ack: AckSender, _state: State<AppState>) {
+    info!("Received git:status");
+    send_response(ack, git_status_impl());
+}
+
+fn git_file_original_impl(request: &GitFileOriginalRequest) -> Result<Value> {
+    let workdir = crate::utils::current_dir();
+    
+    let repo = Repository::discover(&workdir)?;
+    let head = repo.head()?;
+    let commit = head.peel_to_commit()?;
+    let tree = commit.tree()?;
+
+    // Convert absolute path to relative path from repo root
+    let repo_path = repo.workdir().unwrap_or(Path::new("."));
+    let file_path = Path::new(&request.path);
+    
+    let relative_path = if file_path.is_absolute() {
+        file_path.strip_prefix(repo_path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| request.path.clone())
+    } else {
+        request.path.clone()
+    };
+
+    // Get file from tree - if not found, it's a new file
+    let entry = match tree.get_path(Path::new(&relative_path)) {
+        Ok(e) => e,
+        Err(_) => {
+            return Ok(json!({ "content": "", "is_new": true }));
+        }
+    };
+
+    let blob = repo.find_blob(entry.id())?;
+    let content = std::str::from_utf8(blob.content())?.to_string();
+
+    info!("Got original content for {}: {} bytes", relative_path, content.len());
+    Ok(json!({ "content": content, "is_new": false }))
+}
+
+pub async fn handle_git_file_original(
+    Data(request): Data<GitFileOriginalRequest>,
+    ack: AckSender,
+    _state: State<AppState>,
+) {
+    info!("Received git:file-original: {:?}", request.path);
+    send_response(ack, git_file_original_impl(&request));
+}
+
+fn git_commit_impl(request: &GitCommitRequest) -> Result<Value> {
+    let workdir = crate::utils::current_dir();
+    
+    let repo = Repository::discover(&workdir)?;
+    let mut index = repo.index()?;
+
+    // Add files to index
+    for path in &request.files {
+        let path = Path::new(path);
+        let relative_path = if path.is_absolute() {
+            path.strip_prefix(repo.workdir().unwrap_or(Path::new(".")))
+                .unwrap_or(path)
+        } else {
+            path
+        };
+
+        index.add_path(relative_path)?;
+    }
+
+    index.write()?;
+
+    let tree_id = index.write_tree()?;
+
+    let tree = repo.find_tree(tree_id)?;
+
+    let sig = repo.signature().or_else(|_| {
+        git2::Signature::now("Anycode User", "user@anycode.dev")
+    })?;
+
+    // Get HEAD as parent
+    let parents: Vec<git2::Commit> = repo.head()
+        .ok()
+        .and_then(|h| h.peel_to_commit().ok())
+        .map(|c| vec![c])
+        .unwrap_or_default();
+
+    let parents_refs: Vec<&git2::Commit> = parents.iter().collect();
+
+    repo.commit(Some("HEAD"), &sig, &sig, &request.message, &tree, &parents_refs)
+        .context("Failed to commit")?;
+
+    Ok(json!({}))
+}
+
+pub async fn handle_git_commit(
+    Data(request): Data<GitCommitRequest>,
+    ack: AckSender,
+    _state: State<AppState>,
+) {
+    info!("Received git:commit: {} files", request.files.len());
+    send_response(ack, git_commit_impl(&request));
+}
+
+fn git_push_impl() -> Result<Value> {
+    let workdir = crate::utils::current_dir();
+    
+    let repo = Repository::discover(&workdir)?;
+    let mut remote = repo.find_remote("origin")?;
+    let head = repo.head()?;
+
+    let branch_name = head.shorthand()
+        .context("Detached HEAD state")?;
+
+    let refspec = format!("refs/heads/{}:refs/heads/{}", branch_name, branch_name);
+
+    let mut callbacks = git2::RemoteCallbacks::new();
+    callbacks.credentials(|_url, username_from_url, _allowed_types| {
+        git2::Cred::ssh_key_from_agent(username_from_url.unwrap_or("git"))
+    });
+
+    let mut push_opts = git2::PushOptions::new();
+    push_opts.remote_callbacks(callbacks);
+
+    remote.push(&[&refspec], Some(&mut push_opts))?;
+
+    Ok(json!({}))
+}
+
+pub async fn handle_git_push(ack: AckSender, _state: State<AppState>) {
+    info!("Received git:push");
+    send_response(ack, git_push_impl());
+}

anycode-backend/src/handlers/mod.rs

@@ -4,6 +4,7 @@ pub mod search_handler;
 pub mod terminal_handler;
 pub mod watch_handler;
 pub mod acp_handler;
+pub mod git_handler;
 
 // pub use io_handler::*;
 // pub use lsp_handler::*;

anycode-backend/src/main.rs

@@ -39,6 +39,7 @@ use handlers::{
     terminal_handler::*,
     watch_handler::{handle_watch_event},
     acp_handler::*,
+    git_handler::*,
 };
 
 mod search;
@@ -81,6 +82,11 @@ async fn on_connect(socket: SocketRef, state: State<AppState>) {
     socket.on("acp:permission_response", handle_acp_permission_response);
     socket.on("acp:undo", handle_acp_undo);
 
+    socket.on("git:status", handle_git_status);
+    socket.on("git:file-original", handle_git_file_original);
+    socket.on("git:commit", handle_git_commit);
+    socket.on("git:push", handle_git_push);
+
     socket.on_disconnect(on_disconnect)
 }
 

anycode-base/src/editor.ts

@@ -1128,6 +1128,16 @@ export class AnycodeEditor {
         }
     }
 
+    public setOriginalCode(content: string): void {
+        this.originalCode = content;
+        if (this.diffEnabled) {
+            const currentText = this.code.getContent();
+            this.diffs = computeGitChanges(this.originalCode, currentText);
+            this.renderer.render(this.getEditorState(), this.search);
+            this.verifyDiffRendering();
+        }
+    }
+
     private verifyDiffRendering(): void {
         if (!this.diffEnabled || this.diffs === undefined) {
             return;

anycode/App.css

@@ -258,6 +258,23 @@
     text-shadow: 0 0 6px rgba(255, 255, 255, 0.8);
 }
 
+.toggle-mode-btn {
+    background: transparent;
+    border: none;
+    color: #888;
+    cursor: pointer;
+    border-radius: 12px;
+    transition: all 0.2s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 4px;
+}
+
+.toggle-mode-btn:hover {
+    color: #fff;
+}
+
 .editor-toggle-btn {
     background: none;
     border: none;
@@ -425,6 +442,16 @@
     background: linear-gradient(to bottom, transparent, #555, transparent);
 }
 
+.changes-panel::after {
+    content: '';
+    position: absolute;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    width: 1.5px;
+    background: linear-gradient(to bottom, transparent, #555, transparent);
+}
+
 .file-system-content {
     padding: 1px 4px 4px 4px;
     flex: 1;
@@ -455,6 +482,10 @@
 .app-container:not(.terminal-visible) .search-results {
     padding-bottom: var(--toolbar-total-space);
 }
+/* Add bottom padding only when terminal is closed - same approach as file-system-content */
+.app-container:not(.terminal-visible) .changes-list {
+    padding-bottom: var(--toolbar-total-space);
+}
 
 .acp-dialog::after {
     content: '';