zen-gitsync 2.0.5 → 2.0.7

package/src/ui/server/index.js

@@ -8,17 +8,25 @@ import config from '../../config.js';
 import chalk from 'chalk';
 import fs from 'fs/promises';
 import os from 'os';
-// import { Server } from 'socket.io';
+import { Server } from 'socket.io';
+import chokidar from 'chokidar';
 // import { exec } from 'child_process';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const configManager = config; // 确保 configManager 可用
 
+// 文件系统变动监控器
+let watcher = null;
+// 防抖计时器
+let debounceTimer = null;
+// 防抖延迟时间 (毫秒)
+const DEBOUNCE_DELAY = 1000;
+
 async function startUIServer() {
   const app = express();
   const httpServer = createServer(app);
-  // const io = new Server(httpServer);
+  const io = new Server(httpServer);
   
   // 添加全局中间件来解析JSON请求体
   app.use(express.json());
@@ -30,24 +38,6 @@ async function startUIServer() {
     next();
   });
   
-  // // 启动前端Vue应用
-  // const clientPath = path.join(__dirname, '../client');
-  // console.log(`正在启动前端应用，路径: ${clientPath}`);
-  
-  // const vueProcess = exec('npm run dev', { cwd: clientPath }, (error) => {
-  //   if (error) {
-  //     console.error('启动前端应用失败:', error);
-  //   }
-  // });
-  
-  // vueProcess.stdout.on('data', (data) => {
-  //   console.log(`前端输出: ${data}`);
-  // });
-  
-  // vueProcess.stderr.on('data', (data) => {
-  //   console.error(`前端错误: ${data}`);
-  // });
-  
   // 静态文件服务
   app.use(express.static(path.join(__dirname, '../public')));
   
@@ -79,6 +69,74 @@ async function startUIServer() {
     }
   });
 
+  // 获取分支与远程的差异状态（领先/落后提交数）
+  app.get('/api/branch-status', async (req, res) => {
+    try {
+      // 先获取当前分支名
+      const { stdout: branchName } = await execGitCommand('git rev-parse --abbrev-ref HEAD');
+      const currentBranch = branchName.trim();
+      
+      // 获取远程仓库名称
+      const { stdout: remoteName } = await execGitCommand('git remote');
+      const remote = remoteName.trim() || 'origin';
+      
+      // 尝试获取当前分支的上游分支
+      let upstreamBranch = '';
+      let hasUpstream = false;
+      
+      try {
+        const { stdout: upstream } = await execGitCommand(`git rev-parse --abbrev-ref ${currentBranch}@{upstream}`);
+        upstreamBranch = upstream.trim();
+        hasUpstream = true;
+      } catch (error) {
+        // 没有上游分支设置，这是正常的
+        console.log(`分支 ${currentBranch} 没有设置上游分支`);
+        hasUpstream = false;
+      }
+      
+      // 如果分支没有上游设置，直接返回结果
+      if (!hasUpstream) {
+        return res.json({
+          branch: currentBranch,
+          remote,
+          hasUpstream: false,
+          ahead: 0,
+          behind: 0
+        });
+      }
+      
+      // 获取领先和落后的提交数
+      const { stdout: statusCompare } = await execGitCommand(`git rev-list --count --left-right ${currentBranch}...${upstreamBranch}`);
+      
+      // 解析结果，格式通常是 "1  2" 表示领先1个提交，落后2个提交
+      let ahead = 0;
+      let behind = 0;
+      
+      if (statusCompare && statusCompare.trim()) {
+        const parts = statusCompare.trim().split(/\s+/);
+        if (parts.length >= 2) {
+          ahead = parseInt(parts[0]) || 0;
+          behind = parseInt(parts[1]) || 0;
+        } else if (parts.length === 1) {
+          // 只有一个数字的情况，通常是领先的提交数
+          ahead = parseInt(parts[0]) || 0;
+        }
+      }
+      
+      res.json({
+        branch: currentBranch,
+        remote,
+        upstreamBranch,
+        hasUpstream: true,
+        ahead,
+        behind
+      });
+    } catch (error) {
+      console.error("获取分支状态失败:", error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
   // 获取所有分支
   app.get('/api/branches', async (req, res) => {
     try {
@@ -198,7 +256,6 @@ async function startUIServer() {
   // 新增切换工作目录接口
   app.post('/api/change_directory', async (req, res) => {
       try {
-
           const { path } = req.body;
           
           if (!path) {
@@ -212,12 +269,22 @@ async function startUIServer() {
               // 检查新目录是否是Git仓库
               try {
                   await execGitCommand('git rev-parse --is-inside-work-tree');
+                  
+                  // 初始化文件监控
+                  initFileSystemWatcher();
+                  
                   res.json({ 
                       success: true, 
                       directory: newDirectory,
                       isGitRepo: true 
                   });
               } catch (error) {
+                  // 不是Git仓库，停止监控
+                  if (watcher) {
+                    watcher.close().catch(err => console.error('关闭监控器失败:', err));
+                    watcher = null;
+                  }
+                  
                   res.json({ 
                       success: true, 
                       directory: newDirectory,
@@ -482,6 +549,46 @@ async function startUIServer() {
     }
   });
   
+  // 添加单个文件到暂存区
+  app.post('/api/add-file', async (req, res) => {
+    try {
+      const { filePath } = req.body;
+      
+      if (!filePath) {
+        return res.status(400).json({ 
+          success: false, 
+          error: '缺少文件路径参数' 
+        });
+      }
+      
+      // 执行 git add 命令添加特定文件
+      await execGitCommand(`git add "${filePath}"`);
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+  
+  // 从暂存区移除单个文件
+  app.post('/api/unstage-file', async (req, res) => {
+    try {
+      const { filePath } = req.body;
+      
+      if (!filePath) {
+        return res.status(400).json({ 
+          success: false, 
+          error: '缺少文件路径参数' 
+        });
+      }
+      
+      // 执行 git reset HEAD 命令移除特定文件的暂存
+      await execGitCommand(`git reset HEAD -- "${filePath}"`);
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+  
   // 推送更改
   app.post('/api/push', async (req, res) => {
     try {
@@ -495,29 +602,132 @@ async function startUIServer() {
   // 获取日志
   app.get('/api/log', async (req, res) => {
     try {
-      // 获取请求参数中的数量限制，默认为30
-      const limit = req.query.all === 'true' ? '' : '-n 30';
+      // 获取分页参数
+      const page = parseInt(req.query.page) || 1;
+      const limit = parseInt(req.query.limit) || 100;
+      const skip = (page - 1) * limit;
+      
+      // 获取筛选参数
+      const author = req.query.author ? req.query.author.split(',') : [];
+      const message = req.query.message || '';
+      const dateFrom = req.query.dateFrom || '';
+      const dateTo = req.query.dateTo || '';
       
-      // graph参数保留但不做特殊处理，避免前端代码重复调用API
-      // 由前端统一使用该接口
+      // 构建Git命令选项
+      let commandOptions = [];
       
-      // 修改 git log 命令，添加 %ae 参数来获取作者邮箱
-      const { stdout } = await execGitCommand(`git log --all --pretty=format:"%h|%an|%ae|%ad|%s|%D" --date=short ${limit}`);
-      const logs = stdout.split('\n').map(line => {
-        const [hash, author, email, date, message, refs] = line.split('|');
+      // 作者筛选（支持多作者，使用正则表达式OR操作）
+      if (author.length > 0) {
+        // 过滤掉空作者
+        const validAuthors = author.filter(a => a.trim() !== '');
         
-        // 从引用信息中提取分支名称
-        let branch = null;
-        if (refs) {
-          // 提取所有引用信息，而不仅仅是第一个匹配
-          branch = refs.trim();
+        if (validAuthors.length === 1) {
+          // 单个作者，直接使用--author
+          commandOptions.push(`--author="${validAuthors[0].trim()}"`);
+        } else if (validAuthors.length > 1) {
+          // 多个作者，使用正则表达式OR条件
+          // 只转义OR运算符，保持其他内容不变
+          const authorPattern = validAuthors
+            .map(a => a.trim())
+            .join('\\|');  // 在JavaScript字符串中\\|会变成\|，在shell中会成为|
+          
+          commandOptions.push(`--author="${authorPattern}"`);
         }
-        
-        return { hash, author, email, date, message, branch };
+      }
+      
+      // 日期范围筛选
+      if (dateFrom && dateTo) {
+        commandOptions.push(`--after="${dateFrom}" --before="${dateTo} 23:59:59"`);
+      } else if (dateFrom) {
+        commandOptions.push(`--after="${dateFrom}"`);
+      } else if (dateTo) {
+        commandOptions.push(`--before="${dateTo} 23:59:59"`);
+      }
+      
+      // 提交信息筛选
+      if (message) {
+        commandOptions.push(`--grep="${message}"`);
+      }
+      
+      // 如果all=true，则不使用限制，否则按页码和limit精确获取
+      // 修复：只获取当前页的数据，而不是累计所有之前页的数据
+      const limitOption = req.query.all === 'true' ? '' : `-n ${limit} --skip=${skip}`;
+      
+      // 合并所有命令选项
+      const options = [...commandOptions, limitOption].filter(Boolean).join(' ');
+      
+      console.log(`执行Git命令: git log --all --pretty=format:"%H|%an|%ae|%ad|%B|%D" --date=short ${options}`);
+      
+      // 使用 git log 命令获取提交历史
+      let { stdout: logOutput } = await execGitCommand(
+        `git log --all --pretty=format:"%H|%an|%ae|%ad|%B|%D" --date=short ${options}`
+      );
+      
+      // 获取总提交数量（考虑筛选条件）
+      let totalCommits = 0;
+      try {
+        // 构建计数命令，包含相同的筛选条件
+        // 对于作者筛选，使用 rev-list 并手动计数，避免 --count 与复杂作者筛选结合可能的问题
+        if (author.length > 1) {
+          // 多作者情况，使用 wc -l 手动计数
+          const countCommand = `git rev-list --all ${commandOptions.join(' ')}`;
+          console.log(`执行计数命令(多作者): ${countCommand}`);
+          
+          const { stdout: countOutput } = await execGitCommand(countCommand);
+          // 计算行数作为提交数
+          totalCommits = countOutput.trim().split('\n').filter(line => line.trim() !== '').length;
+        } else {
+          // 单作者或无作者筛选，可以直接使用 --count
+          const countCommand = `git rev-list --all --count ${commandOptions.join(' ')}`;
+          console.log(`执行计数命令(单作者): ${countCommand}`);
+          
+          const { stdout: countOutput } = await execGitCommand(countCommand);
+          totalCommits = parseInt(countOutput.trim());
+        }
+      } catch (error) {
+        console.error('获取提交总数失败:', error);
+        totalCommits = 0;
+      }
+      
+      // 替换提交记录之间的换行符
+      logOutput = logOutput.replace(/\n(?=[a-f0-9]{40}\|)/g, "<<<RECORD_SEPARATOR>>>");
+      
+      // 按分隔符拆分日志条目
+      const logEntries = logOutput.split("<<<RECORD_SEPARATOR>>>");
+      
+      // 处理每个日志条目
+      const data = logEntries.map(entry => {
+        const parts = entry.split('|');
+        if (parts.length >= 5) {
+          return {
+            hash: parts[0],
+            author: parts[1],
+            email: parts[2],
+            date: parts[3],
+            message: parts[4],
+            branch: parts[5] || ''
+          };
+        }
+        return null;
+      }).filter(item => item !== null);
+      
+      // 计算是否有更多数据
+      // 修复：使用总记录数和已获取记录总数来判断
+      const hasMore = req.query.all === 'true' ? false : (skip + data.length < totalCommits);
+      
+      console.log(`分页查询 - 页码: ${page}, 每页数量: ${limit}, 跳过: ${skip}, 总数: ${totalCommits}, 返回数量: ${data.length}, 是否有更多: ${hasMore}`);
+      
+      // 返回提交历史数据，包括是否有更多数据的标志
+      res.json({
+        data: data,
+        total: totalCommits,
+        page: page,
+        limit: limit,
+        hasMore: hasMore
       });
-      res.json(logs);
     } catch (error) {
-      res.status(500).json({ error: error.message });
+      console.error('获取Git日志失败:', error);
+      res.status(500).json({ error: '获取日志失败: ' + error.message });
     }
   });
   
@@ -539,6 +749,27 @@ async function startUIServer() {
     }
   });
   
+  // 获取文件内容 (用于未跟踪文件)
+  app.get('/api/file-content', async (req, res) => {
+    try {
+      const filePath = req.query.file;
+      
+      if (!filePath) {
+        return res.status(400).json({ error: '缺少文件路径参数' });
+      }
+      
+      try {
+        // 读取文件内容
+        const content = await fs.readFile(filePath, 'utf8');
+        res.json({ success: true, content });
+      } catch (readError) {
+        res.status(500).json({ success: false, error: `无法读取文件: ${readError.message}` });
+      }
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  
   // 撤回文件修改
   app.post('/api/revert_file', async (req, res) => {
     try {
@@ -630,6 +861,137 @@ async function startUIServer() {
     }
   });
   
+  // 获取提交的文件列表
+  app.get('/api/commit-files', async (req, res) => {
+    try {
+      const hash = req.query.hash;
+      
+      if (!hash) {
+        return res.status(400).json({ 
+          success: false, 
+          error: '缺少提交哈希参数' 
+        });
+      }
+      
+      console.log(`获取提交文件列表: hash=${hash}`);
+      
+      // 执行命令获取提交中修改的文件列表
+      const { stdout } = await execGitCommand(`git show --name-only --format="" ${hash}`);
+      
+      // 将输出按行分割，并过滤掉空行
+      const files = stdout.split('\n').filter(line => line.trim());
+      console.log(`找到${files.length}个文件:`, files);
+      
+      res.json({ 
+        success: true, 
+        files 
+      });
+    } catch (error) {
+      console.error('获取提交文件列表失败:', error);
+      res.status(500).json({ 
+        success: false, 
+        error: `获取提交文件列表失败: ${error.message}` 
+      });
+    }
+  });
+  
+  // 获取提交中特定文件的差异
+  app.get('/api/commit-file-diff', async (req, res) => {
+    try {
+      const hash = req.query.hash;
+      const filePath = req.query.file;
+      
+      if (!hash || !filePath) {
+        return res.status(400).json({ 
+          success: false, 
+          error: '缺少必要参数' 
+        });
+      }
+      
+      console.log(`获取提交文件差异: hash=${hash}, file=${filePath}`);
+      
+      // 执行命令获取文件差异，-p显示补丁，限定文件路径
+      const { stdout } = await execGitCommand(`git show ${hash} -- "${filePath}"`);
+      
+      console.log(`获取到差异内容，长度: ${stdout.length}`);
+      // 如果差异内容太长，只打印前100个字符
+      if (stdout.length > 100) {
+        console.log(`差异内容预览: ${stdout.substring(0, 100)}...`);
+      }
+      
+      res.json({ 
+        success: true, 
+        diff: stdout 
+      });
+    } catch (error) {
+      console.error('获取提交文件差异失败:', error);
+      res.status(500).json({ 
+        success: false, 
+        error: `获取提交文件差异失败: ${error.message}` 
+      });
+    }
+  });
+  
+  // 撤销某个提交 (revert)
+  app.post('/api/revert-commit', async (req, res) => {
+    try {
+      const { hash } = req.body;
+      
+      if (!hash) {
+        return res.status(400).json({ 
+          success: false, 
+          error: '缺少提交哈希参数' 
+        });
+      }
+      
+      console.log(`执行撤销提交操作: hash=${hash}`);
+      
+      // 执行git revert命令
+      await execGitCommand(`git revert --no-edit ${hash}`);
+      
+      res.json({ 
+        success: true, 
+        message: `已成功撤销提交 ${hash}` 
+      });
+    } catch (error) {
+      console.error('撤销提交失败:', error);
+      res.status(500).json({ 
+        success: false, 
+        error: `撤销提交失败: ${error.message}` 
+      });
+    }
+  });
+  
+  // Cherry-pick某个提交
+  app.post('/api/cherry-pick-commit', async (req, res) => {
+    try {
+      const { hash } = req.body;
+      
+      if (!hash) {
+        return res.status(400).json({ 
+          success: false, 
+          error: '缺少提交哈希参数' 
+        });
+      }
+      
+      console.log(`执行Cherry-pick操作: hash=${hash}`);
+      
+      // 执行git cherry-pick命令
+      await execGitCommand(`git cherry-pick ${hash}`);
+      
+      res.json({ 
+        success: true, 
+        message: `已成功Cherry-pick提交 ${hash}` 
+      });
+    } catch (error) {
+      console.error('Cherry-pick提交失败:', error);
+      res.status(500).json({ 
+        success: false, 
+        error: `Cherry-pick提交失败: ${error.message}` 
+      });
+    }
+  });
+  
   // 添加清理Git锁定文件的接口
   app.post('/api/remove-lock', async (req, res) => {
     try {
@@ -714,25 +1076,153 @@ async function startUIServer() {
     }
   });
   
+        // 获取所有作者列表
+  app.get('/api/authors', async (req, res) => {
+    try {
+      // 使用git命令获取所有提交者，不依赖Unix命令
+      const { stdout } = await execGitCommand('git log --format="%an"');
+      
+      // 将结果按行分割并过滤空行
+      const lines = stdout.split('\n').filter(author => author.trim() !== '');
+      
+      // 手动去重，不依赖Unix的uniq命令
+      const uniqueAuthors = Array.from(new Set(lines)).sort();
+      
+      // 控制台输出一下搜索示例，方便调试
+      if (uniqueAuthors.length > 1) {
+        const searchExample = uniqueAuthors.slice(0, 2).join('|');
+        console.log(`多作者搜索示例: git log --author="${searchExample}"`);
+      }
+      
+      res.json({
+        success: true,
+        authors: uniqueAuthors
+      });
+    } catch (error) {
+      console.error('获取作者列表失败:', error);
+      res.status(500).json({
+        success: false,
+        error: '获取作者列表失败: ' + error.message
+      });
+    }
+  });
+  
   // Socket.io 实时更新
-  // io.on('connection', (socket) => {
-  //   console.log('客户端已连接');
+  io.on('connection', (socket) => {
+    console.log('客户端已连接:', socket.id);
     
-  //   // 定期发送状态更新
-  //   const statusInterval = setInterval(async () => {
-  //     try {
-  //       const { stdout } = await execGitCommand('git status');
-  //       socket.emit('status_update', { status: stdout });
-  //     } catch (error) {
-  //       console.error('状态更新错误:', error);
-  //     }
-  //   }, 5000);
+    // 当客户端连接时，立即发送一次Git状态
+    getAndBroadcastStatus();
+    
+    // 客户端可以请求开始/停止监控
+    socket.on('start_monitoring', () => {
+      if (!watcher) {
+        initFileSystemWatcher();
+        socket.emit('monitoring_status', { active: true });
+      }
+    });
     
-  //   socket.on('disconnect', () => {
-  //     clearInterval(statusInterval);
-  //     console.log('客户端已断开连接');
-  //   });
-  // });
+    socket.on('stop_monitoring', () => {
+      if (watcher) {
+        watcher.close().catch(err => console.error('关闭监控器失败:', err));
+        watcher = null;
+        socket.emit('monitoring_status', { active: false });
+      }
+    });
+    
+    // 客户端断开连接
+    socket.on('disconnect', () => {
+      console.log('客户端已断开连接:', socket.id);
+    });
+  });
+  
+  // 初始化文件系统监控
+  function initFileSystemWatcher() {
+    // 停止已有的监控器
+    if (watcher) {
+      watcher.close().catch(err => console.error('关闭旧监控器失败:', err));
+    }
+    
+    try {
+      // 获取当前工作目录
+      const currentDir = process.cwd();
+      
+      console.log(`初始化文件系统监控器，路径: ${currentDir}`);
+      
+      // 检查是否是Git仓库
+      try {
+        execGitCommand('git rev-parse --is-inside-work-tree');
+      } catch (error) {
+        console.log('当前目录不是Git仓库，不启动监控');
+        return;
+      }
+      
+      // 使用chokidar监控文件变动
+      watcher = chokidar.watch(currentDir, {
+        ignored: [
+          /(^|[\/\\])\../, // 忽略.开头的文件和目录
+          '**/node_modules/**', // 忽略node_modules
+          '**/.git/**', // 忽略.git目录
+        ],
+        persistent: true,
+        ignoreInitial: true, // 忽略初始扫描时的文件
+        awaitWriteFinish: {
+          stabilityThreshold: 300, // 等待文件写入完成的时间
+          pollInterval: 100 // 轮询间隔
+        }
+      });
+      
+      // 合并所有变动事件到一个处理程序
+      const events = ['add', 'change', 'unlink'];
+      events.forEach(event => {
+        watcher.on(event, path => {
+          console.log(`检测到文件变动 [${event}]: ${path}`);
+          debouncedNotifyChanges();
+        });
+      });
+      
+      watcher.on('error', error => {
+        console.error('文件监控错误:', error);
+      });
+      
+      console.log('文件系统监控器已启动');
+    } catch (error) {
+      console.error('启动文件监控失败:', error);
+    }
+  }
+  
+  // 获取并广播Git状态
+  async function getAndBroadcastStatus() {
+    try {
+      // 获取常规状态
+      const { stdout: statusOutput } = await execGitCommand('git status');
+      
+      // 获取porcelain格式状态
+      const { stdout: porcelainOutput } = await execGitCommand('git status --porcelain');
+      
+      // 广播到所有连接的客户端
+      io.emit('git_status_update', { 
+        status: statusOutput,
+        porcelain: porcelainOutput,
+        timestamp: new Date().toISOString()
+      });
+      
+      console.log('已广播Git状态更新');
+    } catch (error) {
+      console.error('获取或广播Git状态失败:', error);
+    }
+  }
+  
+  // 防抖处理函数
+  function debouncedNotifyChanges() {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    
+    debounceTimer = setTimeout(() => {
+      getAndBroadcastStatus();
+    }, DEBOUNCE_DELAY);
+  }
   
   // 启动服务器
   const PORT = 3000;
@@ -742,6 +1232,10 @@ async function startUIServer() {
     console.log(chalk.green(`  访问地址: http://localhost:${PORT}`));
     console.log(chalk.green(`  启动时间: ${new Date().toLocaleString()}`));
     console.log(chalk.green('======================================'));
+    
+    // 启动文件监控
+    initFileSystemWatcher();
+    
     open(`http://localhost:${PORT}`);
   }).on('error', async (err) => {
     if (err.code === 'EADDRINUSE') {
@@ -756,6 +1250,10 @@ async function startUIServer() {
               console.log(chalk.green(`  访问地址: http://localhost:${newPort}`));
               console.log(chalk.green(`  启动时间: ${new Date().toLocaleString()}`));
               console.log(chalk.green('======================================'));
+              
+              // 启动文件监控
+              initFileSystemWatcher();
+              
               open(`http://localhost:${newPort}`);
               resolve();
             }).on('error', (e) => {