feat: enable autosave by default and simplify save UX

- add autosave to backend config with a default value of true
- save file content automatically on file:change when autosave is enabled
- notify LSP with did_save after successful autosave
- remove frontend dirty-state tracking and related state updates
- remove tab dirty indicator from file tabs
- adjust file watch debounce flow to use tokio::sync::watch
- apply small editor/UI style tweaks

Author: vipmax

anycode-backend/config.toml

@@ -1,5 +1,6 @@
 theme = "themes/vesper.yml"
 left_panel_width = 25
+autosave = true
 
 terminal.command = "bash"
 
@@ -148,4 +149,4 @@ exec = "dotnet run {file}"
 name = "json"
 types = [".json"]
 comment = "//"
-indent = { width = 2, unit = " " }
+indent = { width = 2, unit = " " }

anycode-backend/src/config.rs

@@ -18,6 +18,8 @@ pub struct Config {
     pub theme: String,
     pub language: Vec<Language>,
     pub terminal: Option<Terminal>,
+    #[serde(default = "default_autosave")]
+    pub autosave: bool,
 }
 
 impl Config {
@@ -26,10 +28,15 @@ impl Config {
             theme: "default".to_string(),
             language: vec![],
             terminal: None,
+            autosave: default_autosave(),
         }
     }
 }
 
+fn default_autosave() -> bool {
+    true
+}
+
 #[derive(Debug, Deserialize, Clone)]
 pub struct Language {
     pub name: String,

anycode-backend/src/handlers/io_handler.rs

@@ -293,6 +293,14 @@ pub async fn handle_file_change(
         }
     }
 
+    if state.config.autosave {
+        if let Err(e) = code.save_file() {
+            error!("Autosave failed for {}: {:?}", abs_path, e);
+        } else if let Some(lsp) = lsp_manager.get(&code.lang).await {
+            lsp.did_save(&abs_path, Some(&code.text.to_string()));
+        }
+    }
+
     // Broadcast as a single message for other clients if needed
     socket.broadcast().emit("file:change", &change).await.ok();
 }
@@ -411,4 +419,4 @@ pub async fn handle_create(
             }
         }
     }
-}
+}

anycode-backend/src/handlers/watch_handler.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::collections::HashMap;
 use std::time::Duration;
-use tokio::sync::{Mutex, Notify};
+use tokio::sync::{Mutex, watch};
 use serde_json::json;
 use tracing::info;
 use anyhow::Result;
@@ -13,15 +13,15 @@ use crate::app_state::SocketData;
 use crate::code::Code;
 use crate::diff::compute_text_edits;
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)] // Added Copy/Clone/PartialEq if needed by usage, sticking to original Clone/PartialEq + Debug
 enum FileState {
     Exists,
     DoesNotExist,
 }
 
 pub struct FileWatchState {
     pub state: FileState,
-    pub notify: Arc<Notify>,
+    pub sender: watch::Sender<()>,
     pub pending: bool,
 }
 
@@ -109,33 +109,30 @@ pub async fn handle_watch_event(
     git_manager: &Arc<Mutex<crate::git::GitManager>>,
 ) {
     let path_str = match path.to_str() {
-        Some(s) => s.to_string(),
-        None => return,
+        Some(s) => s.to_string(), None => return,
     };
 
-    let should_spawn = {
+    let (should_spawn, rx) = {
         let mut states = file_states.lock().await;
-        let entry = states.entry(path_str.clone()).or_insert_with(|| FileWatchState {
-            state: FileState::DoesNotExist, // never seen = didn't exist for us
-            notify: Arc::new(Notify::new()),
-            pending: false,
+        let entry = states.entry(path_str.clone()).or_insert_with(|| {
+            let (tx, _) = watch::channel(());
+            FileWatchState { state: FileState::DoesNotExist, sender: tx, pending: false, }
         });
 
-        // Signal the existing task to reset its timer
-        entry.notify.notify_one();
+        let _ = entry.sender.send(());
 
         if entry.pending {
-            // A task is already waiting — it will pick up the new event
-            false
+            (false, None)
         } else {
             entry.pending = true;
-            true
+            let receiver = entry.sender.subscribe();
+            (true, Some(receiver))
         }
     };
 
-    if !should_spawn {
-        return;
-    }
+    if !should_spawn { return; }
+
+    let mut rx = rx.unwrap();
 
     // Spawn a single debounce task for this file
     let path = path.clone();
@@ -144,33 +141,30 @@ pub async fn handle_watch_event(
     let socket2data = socket2data.clone();
     let file_states = file_states.clone();
     let git_manager = git_manager.clone();
-
-    // Get the notify handle for this file
-    let file_notify = {
-        let states = file_states.lock().await;
-        states.get(&path_str).unwrap().notify.clone()
-    };
+    let path_str_key = path_str.clone();
 
     tokio::spawn(async move {
         // Wait until events stop arriving (trailing-edge debounce)
         loop {
-            match tokio::time::timeout(DEBOUNCE, file_notify.notified()).await {
+            // Mark as seen so we wait for *new* changes
+            let _ = rx.borrow_and_update();
+            match tokio::time::timeout(DEBOUNCE, rx.changed()).await {
                 Ok(_) => continue,  // new event arrived — reset timer
                 Err(_) => break,    // timeout — silence, time to process
             }
         }
 
         process_watch_event(
-            &path, &path_str, &socket, &file2code, &socket2data, &file_states, &git_manager,
+            &path, &path_str_key, &socket, &file2code, &socket2data, &file_states, &git_manager,
         ).await;
 
         // Mark as not pending so future events spawn a new task
-        {
-            let mut states = file_states.lock().await;
-            if let Some(state) = states.get_mut(&path_str) {
-                state.pending = false;
-            }
+        
+        let mut states = file_states.lock().await;
+        if let Some(state) = states.get_mut(&path_str_key) {
+            state.pending = false;
         }
+        
     });
 }
 

anycode-base/src/editor.ts

@@ -68,7 +68,7 @@ export class AnycodeEditor {
 
     private search: Search = new Search();
 
-    private diffEnabled: boolean = true;
+    private diffEnabled: boolean = false;
     private originalCode?: string;
     private diffs?: Map<number, DiffInfo>;
 

anycode-base/src/styles.css

@@ -83,44 +83,44 @@
   position: relative;
 }
 
-.gutter .ln.diff-changed::before {
+/* .gutter .ln.diff-changed::before {
   content: '';
   position: absolute;
   left: -5px;
   top: 0;
   bottom: 0;
   width: 3px;
   background-color: rgba(48, 123, 215, 0.8);
-}
+} */
 
 .diff-added {
   background-color: rgba(76, 175, 79, 0.206);
   position: relative;
 }
 
-.gutter .ln.diff-added::before {
+/* .gutter .ln.diff-added::before {
   content: '';
   position: absolute;
   left: -6px;
   top: 0;
   bottom: 0;
   width: 3px;
   background-color: rgba(76, 175, 79, 0.405);
-}
+} */
 
-.gutter .ln.diff-deleted {
+/* .gutter .ln.diff-deleted {
   position: relative;
-}
+} */
 
-.gutter .ln.diff-deleted::before {
+/* .gutter .ln.diff-deleted::before {
   content: '';
   position: absolute;
   left: -6px;
   bottom: 0;
   width: 2px;
   height: 5px;
   background-color: rgba(244, 67, 54, 0.5);
-}
+} */
 
 
 .completion-box {
@@ -164,10 +164,10 @@
 }
 
 .line-deleted-ghost {
-  color: #f44336;
+  color: #f6564b;
   opacity: 0.6;
   background-color: rgba(244, 67, 54, 0.15);
-  pointer-events: none;
+  /* pointer-events: none; */
   user-select: none;
 }
 

anycode/App.css

@@ -60,8 +60,8 @@
     overflow: hidden;
     /* text-overflow: ellipsis; */
     /* height: 100%; */
-    padding-left: 4px;
-    padding-right: 4px;
+    padding-left: 8px;
+    /* padding-right: 4px; */
 
 }
 
@@ -121,11 +121,11 @@
     align-items: center;
     position: absolute;
     bottom: var(--toolbar-bottom-margin);
-    left: 16px;
-    right: 16px;
+    left: 8px;
+    right: 8px;
     user-select: none;
     z-index: 1000;
-    border-radius: 16px;
+    border-radius: 12px;
     box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
     height: var(--toolbar-height);
     border: 1px solid rgb(70, 70, 70);

anycode/App.tsx

@@ -40,8 +40,6 @@ const App: React.FC = () => {
     const [files, setFiles] = useState<FileState[]>([]);
     const filesRef = useRef<FileState[]>([]);
     const savedFileContentsRef = useRef<Map<string, string>>(new Map());
-    const dirtyFlagsRef = useRef<Map<string, boolean>>(new Map());
-    const [dirtyFlags, setDirtyFlags] = useState<Map<string, boolean>>(new Map());
     const [activeFileId, setActiveFileId] = useState<string | null>(null);
     const [editorStates, setEditorStates] = useState<Map<string, AnycodeEditor>>(new Map());
     const editorRefs = useRef<Map<string, AnycodeEditor>>(new Map());
@@ -176,8 +174,7 @@ const App: React.FC = () => {
                     if (pendingDiff !== undefined) {
                         editor.setOriginalCode(pendingDiff);
                         editor.setDiffEnabled(true);
-                        // Optional: clear it if we don't want to persist across re-opens without re-fetching
-                        // pendingOriginalContentRef.current.delete(file.id);
+                        pendingOriginalContentRef.current.delete(file.id);
                     }
                 } else {
                     // if editor already exists, just use it
@@ -301,22 +298,7 @@ const App: React.FC = () => {
         let oldcontent = savedFileContentsRef.current.get(file.id);
         if (!oldcontent) return;
 
-        let newContentLength = editor.getTextLength();
 
-        let isDirty = false;
-        if (newContentLength !== oldcontent.length) {
-            isDirty = true;
-        } else {
-            let newContent = editor.getText();
-            isDirty = newContent !== oldcontent;
-        }
-
-        const currentDirtyFlag = dirtyFlagsRef.current.get(file.id);
-        if (currentDirtyFlag !== isDirty) {
-            console.log('setDirtyFlags', file.id, isDirty);
-            dirtyFlagsRef.current.set(file.id, isDirty);
-            setDirtyFlags(prev => new Map(prev).set(file.id, isDirty));
-        }
     };
 
     const handleCursorChange = (filename: string, newCursor: Position, oldCursor: Position) => {
@@ -361,12 +343,6 @@ const App: React.FC = () => {
         editorRefs.current.delete(fileId);
 
         savedFileContentsRef.current.delete(fileId);
-        dirtyFlagsRef.current.delete(fileId);
-        setDirtyFlags(prev => {
-            const newFlags = new Map(prev);
-            newFlags.delete(fileId);
-            return newFlags;
-        });
 
         // Unselect the closed file in the tree
         if (fileToClose) {
@@ -412,8 +388,6 @@ const App: React.FC = () => {
         if (response.success) {
             console.log('File saved successfully:', fileId);
             savedFileContentsRef.current.set(fileId, content);
-            dirtyFlagsRef.current.set(fileId, false);
-            setDirtyFlags(prev => new Map(prev).set(fileId, false));
         } else {
             console.error('Failed to save file:', response.error);
         }
@@ -2044,7 +2018,6 @@ const App: React.FC = () => {
                         className={`tab ${activeFileId === file.id ? 'active' : ''}`}
                         onClick={() => openTab(file)}
                     >
-                        <span className={`tab-dirty-indicator ${dirtyFlags.get(file.id) ? 'dirty' : ''}`}> ● </span>
                         <span className="tab-filename"> {file.name} </span>
                         <button className="tab-close-button" onClick={(e) => { e.stopPropagation(); closeTab(file); }}> × </button>
                     </div>