Enhance Git features, editor capabilities, and task management

package.json

@@ -1,7 +1,7 @@
 {
   "name": "codeforge",
   "private": true,
-  "version": "26.2.0",
+  "version": "26.3.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -32,6 +32,7 @@
     "@codemirror/state": "^6.5.2",
     "@codemirror/view": "^6.38.1",
     "@open-rpc/client-js": "^2.0.0",
+    "@replit/codemirror-minimap": "^0.5.2",
     "@tauri-apps/api": "^2",
     "@tauri-apps/plugin-dialog": "^2.3.2",
     "@tauri-apps/plugin-fs": "^2.4.2",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "CodeForge"
-version = "26.2.0"
+version = "26.3.0"
 description = "CodeForge 是一款轻量级、高性能的桌面代码执行器，专为开发者、学生和编程爱好者设计。"
 authors = ["devlive-community"]
 edition = "2024"

src-tauri/src/config.rs

@@ -20,6 +20,8 @@ pub struct EditorConfig {
     pub show_line_numbers: Option<bool>,   // 是否显示行号
     pub show_function_help: Option<bool>,  // 是否显示函数帮助
     pub space_dot_omission: Option<bool>,  // 是否显示空格省略
+    pub show_minimap: Option<bool>,        // 是否显示代码缩略图
+    pub show_sticky_scroll: Option<bool>,  // 是否启用粘性滚动
     pub layout: Option<String>,            // 编辑器/控制台布局: horizontal | vertical | editor
     pub last_direction: Option<String>,    // 仅编辑器模式下控制台弹出方向: horizontal | vertical
     pub max_open_file_size: Option<u32>,   // 打开文件大小上限(MB)，超过则拒绝打开
@@ -69,6 +71,8 @@ impl Default for AppConfig {
                 show_line_numbers: Some(true),
                 show_function_help: Some(false),
                 space_dot_omission: Some(false),
+                show_minimap: Some(false),
+                show_sticky_scroll: Some(false),
                 layout: Some("horizontal".to_string()),
                 last_direction: Some("horizontal".to_string()),
                 max_open_file_size: Some(5),
@@ -139,6 +143,8 @@ impl ConfigManager {
                                 show_line_numbers: Some(true),
                                 show_function_help: Some(false),
                                 space_dot_omission: Some(false),
+                                show_minimap: Some(false),
+                                show_sticky_scroll: Some(false),
                                 layout: Some("horizontal".to_string()),
                                 last_direction: Some("horizontal".to_string()),
                                 max_open_file_size: Some(5),
@@ -262,6 +268,8 @@ impl ConfigManager {
                 show_line_numbers: Some(true),
                 show_function_help: Some(false),
                 space_dot_omission: Some(false),
+                show_minimap: Some(false),
+                show_sticky_scroll: Some(false),
                 layout: Some("horizontal".to_string()),
                 last_direction: Some("horizontal".to_string()),
                 max_open_file_size: Some(5),

src-tauri/src/dap.rs

@@ -0,0 +1,306 @@
+//! DAP 桥接：按语言拉起调试适配器进程，转发 DAP 消息（与 LSP 同为 Content-Length 帧）。
+//! 后端只做透明转发：前端发送/接收原始 JSON 字符串，握手与协议由前端的 DAP 客户端负责。
+//! 复用 lsp.rs 的 find_in_path / augmented_path / read_message。
+
+use crate::lsp::{augmented_path, find_in_path, read_message, read_raw_line};
+use serde::Serialize;
+use std::collections::HashMap;
+use std::io::{BufReader, Read, Write};
+use std::process::{Child, Command, Stdio};
+use std::sync::Mutex as StdMutex;
+use tauri::{AppHandle, Emitter, State};
+
+struct Adapter {
+    child: Child,
+    // 写入走独立线程，避免 stdin 写阻塞主线程
+    tx: std::sync::mpsc::Sender<Vec<u8>>,
+}
+
+pub struct DapState {
+    // 以会话 key 区分（前端通常传语言名，单语言单会话）
+    adapters: StdMutex<HashMap<String, Adapter>>,
+}
+
+impl DapState {
+    pub fn new() -> Self {
+        Self {
+            adapters: StdMutex::new(HashMap::new()),
+        }
+    }
+}
+
+#[derive(Clone, Serialize)]
+struct DapBatch {
+    session: String,
+    messages: Vec<String>,
+}
+
+/// 语言 -> (适配器可执行名, 启动参数)。适配器仅负责说 DAP；
+/// 具体调试目标(program/args/cwd)由前端在 launch 请求中给出。新增语言在此加一行。
+fn adapter_cmd(language: &str) -> Option<(&'static str, Vec<&'static str>)> {
+    match language {
+        // debugpy：python -m debugpy.adapter（需 pip install debugpy）
+        "python" | "python3" | "python2" => Some(("python3", vec!["-m", "debugpy.adapter"])),
+        // delve：dlv dap
+        "go" => Some(("dlv", vec!["dap"])),
+        // lldb-dap（LLVM 自带）：适用于 Rust / C / C++
+        "rust" | "c" | "cpp" => Some(("lldb-dap", vec![])),
+        _ => None,
+    }
+}
+
+/// 该语言是否有可用的调试适配器。Python 进一步校验 debugpy 模块是否可导入。
+#[tauri::command]
+pub fn dap_available(language: String) -> bool {
+    let Some((prog, _)) = adapter_cmd(&language) else {
+        return false;
+    };
+    let Some(exe) = find_in_path(prog) else {
+        return false;
+    };
+    if matches!(language.as_str(), "python" | "python3" | "python2") {
+        return Command::new(&exe)
+            .args(["-c", "import debugpy"])
+            .env("PATH", augmented_path())
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false);
+    }
+    true
+}
+
+/// 启动调试适配器；已启动则直接返回 true。session 作为多会话区分键（前端传语言名即可）。
+#[tauri::command]
+pub fn dap_start(
+    app: AppHandle,
+    state: State<'_, DapState>,
+    session: String,
+    language: String,
+) -> Result<bool, String> {
+    {
+        let adapters = state.adapters.lock().map_err(|e| e.to_string())?;
+        if adapters.contains_key(&session) {
+            return Ok(true);
+        }
+    }
+    let (prog, args) = adapter_cmd(&language).ok_or_else(|| "该语言暂不支持调试".to_string())?;
+    let exe = find_in_path(prog)
+        .ok_or_else(|| format!("未找到调试适配器：{}（请先安装并确保在 PATH 中）", prog))?;
+
+    let mut cmd = Command::new(&exe);
+    cmd.args(&args)
+        .env("PATH", augmented_path())
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+
+    let mut child = cmd
+        .spawn()
+        .map_err(|e| format!("启动 {} 失败: {}", prog, e))?;
+    let stdin = child.stdin.take().ok_or("无法获取 stdin")?;
+    let stdout = child.stdout.take().ok_or("无法获取 stdout")?;
+    let stderr = child.stderr.take();
+
+    // 读取线程：解析 Content-Length 帧，丢进 channel
+    let (msg_tx, msg_rx) = std::sync::mpsc::channel::<String>();
+    std::thread::spawn(move || {
+        let mut reader = BufReader::new(stdout);
+        while let Some(body) = read_message(&mut reader) {
+            if msg_tx.send(body).is_err() {
+                break;
+            }
+        }
+    });
+
+    // 发射线程：合批转发（output/variables 等可能突发），会话结束发 dap:exit
+    let app_reader = app.clone();
+    let sess_emit = session.clone();
+    std::thread::spawn(move || {
+        while let Ok(first) = msg_rx.recv() {
+            let mut batch = vec![first];
+            while let Ok(m) = msg_rx.try_recv() {
+                batch.push(m);
+                if batch.len() >= 256 {
+                    break;
+                }
+            }
+            let _ = app_reader.emit(
+                "dap:messages",
+                DapBatch {
+                    session: sess_emit.clone(),
+                    messages: batch,
+                },
+            );
+        }
+        let _ = app_reader.emit("dap:exit", sess_emit.clone());
+    });
+
+    // 排空 stderr，避免阻塞
+    if let Some(mut err) = stderr {
+        std::thread::spawn(move || {
+            let mut buf = [0u8; 4096];
+            while let Ok(n) = err.read(&mut buf) {
+                if n == 0 {
+                    break;
+                }
+            }
+        });
+    }
+
+    // 写入线程：独占 stdin，从 channel 取帧写入
+    let (tx, rx) = std::sync::mpsc::channel::<Vec<u8>>();
+    std::thread::spawn(move || {
+        let mut stdin = stdin;
+        while let Ok(frame) = rx.recv() {
+            if stdin.write_all(&frame).is_err() {
+                break;
+            }
+            if stdin.flush().is_err() {
+                break;
+            }
+        }
+    });
+
+    state
+        .adapters
+        .lock()
+        .map_err(|e| e.to_string())?
+        .insert(session, Adapter { child, tx });
+    Ok(true)
+}
+
+/// 向调试适配器发送一条 DAP 消息（已是完整 JSON 字符串）
+#[tauri::command]
+pub fn dap_send(
+    state: State<'_, DapState>,
+    session: String,
+    message: String,
+) -> Result<(), String> {
+    let adapters = state.adapters.lock().map_err(|e| e.to_string())?;
+    let adapter = adapters
+        .get(&session)
+        .ok_or_else(|| "调试会话未启动".to_string())?;
+    let frame = format!("Content-Length: {}\r\n\r\n{}", message.len(), message);
+    adapter
+        .tx
+        .send(frame.into_bytes())
+        .map_err(|_| "调试适配器写入通道已关闭".to_string())?;
+    Ok(())
+}
+
+/// 停止调试会话
+#[tauri::command]
+pub fn dap_stop(state: State<'_, DapState>, session: String) -> Result<(), String> {
+    if let Some(mut adapter) = state
+        .adapters
+        .lock()
+        .map_err(|e| e.to_string())?
+        .remove(&session)
+    {
+        let _ = adapter.child.kill();
+    }
+    Ok(())
+}
+
+// 可安装的调试适配器：(id, 展示名, 安装命令)
+fn adapter_defs() -> Vec<(&'static str, &'static str, &'static str)> {
+    vec![
+        (
+            "debugpy",
+            "Python (debugpy)",
+            "python3 -m pip install debugpy",
+        ),
+        (
+            "delve",
+            "Go (delve)",
+            "go install github.com/go-delve/delve/cmd/dlv@latest",
+        ),
+    ]
+}
+
+fn adapter_installed(id: &str) -> bool {
+    match id {
+        // debugpy 校验模块可导入
+        "debugpy" => dap_available("python".to_string()),
+        "delve" => find_in_path("dlv").is_some(),
+        _ => false,
+    }
+}
+
+#[derive(Serialize)]
+pub struct DapAdapterInfo {
+    id: String,
+    label: String,
+    installed: bool,
+    install: String,
+}
+
+/// 列出可安装的调试适配器及其安装状态
+#[tauri::command]
+pub fn dap_adapter_list() -> Vec<DapAdapterInfo> {
+    adapter_defs()
+        .into_iter()
+        .map(|(id, label, install)| DapAdapterInfo {
+            id: id.to_string(),
+            label: label.to_string(),
+            installed: adapter_installed(id),
+            install: install.to_string(),
+        })
+        .collect()
+}
+
+/// 一键安装某调试适配器：执行安装命令并实时输出日志（事件 dap:install / dap:install-done）
+#[tauri::command]
+pub fn dap_install(app: AppHandle, id: String) -> Result<(), String> {
+    let def = adapter_defs()
+        .into_iter()
+        .find(|(d, ..)| *d == id)
+        .ok_or_else(|| "未知的调试适配器".to_string())?;
+    let cmd_str = def.2.to_string();
+
+    let (shell, flag) = if cfg!(windows) {
+        ("cmd", "/C")
+    } else {
+        ("sh", "-c")
+    };
+    let mut child = Command::new(shell)
+        .arg(flag)
+        .arg(&cmd_str)
+        .env("PATH", augmented_path())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("无法执行安装命令: {}", e))?;
+
+    let stdout = child.stdout.take();
+    let stderr = child.stderr.take();
+    let id_done = id.clone();
+    let app_done = app.clone();
+
+    let emit_lines = |app: AppHandle, id: String, reader: Option<Box<dyn Read + Send>>| {
+        if let Some(r) = reader {
+            std::thread::spawn(move || {
+                let mut buf = BufReader::new(r);
+                while let Some(line) = read_raw_line(&mut buf) {
+                    let _ = app.emit("dap:install", (id.clone(), line));
+                }
+            });
+        }
+    };
+    emit_lines(
+        app.clone(),
+        id.clone(),
+        stdout.map(|s| Box::new(s) as Box<dyn Read + Send>),
+    );
+    emit_lines(
+        app.clone(),
+        id.clone(),
+        stderr.map(|s| Box::new(s) as Box<dyn Read + Send>),
+    );
+
+    std::thread::spawn(move || {
+        let success = child.wait().map(|s| s.success()).unwrap_or(false);
+        let _ = app_done.emit("dap:install-done", (id_done, success));
+    });
+    Ok(())
+}