kiro-spec-engine 1.2.3 → 1.4.0

package/lib/workspace/workspace-manager.js

@@ -0,0 +1,370 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+/**
+ * WorkspaceManager - 管理个人工作区
+ * 
+ * 为多用户协作提供隔离的个人工作区
+ */
+class WorkspaceManager {
+  constructor() {
+    this.workspaceBaseDir = '.kiro/workspace';
+    this.gitignoreContent = '# Personal workspaces - not committed\n*\n!.gitignore\n';
+  }
+
+  /**
+   * 初始化个人工作区
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {string} username - 用户名（可选，自动检测）
+   * @returns {Promise<Object>} 初始化结果
+   */
+  async initWorkspace(projectPath, username = null) {
+    try {
+      // 检测用户名
+      const detectedUsername = username || await this.detectUsername();
+      
+      if (!detectedUsername) {
+        return {
+          success: false,
+          error: 'Could not detect username. Please provide username explicitly.',
+          username: null
+        };
+      }
+
+      // 创建工作区目录
+      const workspacePath = path.join(projectPath, this.workspaceBaseDir, detectedUsername);
+      await fs.ensureDir(workspacePath);
+
+      // 创建 CURRENT_CONTEXT.md
+      const contextPath = path.join(workspacePath, 'CURRENT_CONTEXT.md');
+      if (!await fs.pathExists(contextPath)) {
+        const contextTemplate = this.generateContextTemplate(detectedUsername);
+        await fs.writeFile(contextPath, contextTemplate, 'utf8');
+      }
+
+      // 创建 task-state.json
+      const taskStatePath = path.join(workspacePath, 'task-state.json');
+      if (!await fs.pathExists(taskStatePath)) {
+        const initialState = {
+          username: detectedUsername,
+          createdAt: new Date().toISOString(),
+          lastSyncAt: null,
+          currentSpec: null,
+          taskState: {}
+        };
+        await fs.writeFile(taskStatePath, JSON.stringify(initialState, null, 2), 'utf8');
+      }
+
+      // 创建 sync.log
+      const syncLogPath = path.join(workspacePath, 'sync.log');
+      if (!await fs.pathExists(syncLogPath)) {
+        await fs.writeFile(syncLogPath, '', 'utf8');
+      }
+
+      // 确保 .gitignore 存在
+      await this.ensureGitignore(projectPath);
+
+      return {
+        success: true,
+        username: detectedUsername,
+        workspacePath,
+        filesCreated: ['CURRENT_CONTEXT.md', 'task-state.json', 'sync.log']
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        username: username
+      };
+    }
+  }
+
+  /**
+   * 检测当前用户名
+   * 
+   * 优先级：git config > 环境变量 > 系统用户名
+   * 
+   * @returns {Promise<string|null>} 用户名或 null
+   */
+  async detectUsername() {
+    try {
+      // 1. 尝试从 git config 获取
+      try {
+        const gitUsername = execSync('git config user.name', { 
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'ignore']
+        }).trim();
+        
+        if (gitUsername) {
+          return gitUsername;
+        }
+      } catch (error) {
+        // Git 不可用或未配置，继续尝试其他方法
+      }
+
+      // 2. 尝试从环境变量获取
+      const envUsername = process.env.USER || process.env.USERNAME;
+      if (envUsername) {
+        return envUsername;
+      }
+
+      // 3. 尝试从系统获取
+      const osUsername = os.userInfo().username;
+      if (osUsername) {
+        return osUsername;
+      }
+
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * 获取当前用户的工作区路径
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {string} username - 用户名（可选，自动检测）
+   * @returns {Promise<string|null>} 工作区路径或 null
+   */
+  async getWorkspacePath(projectPath, username = null) {
+    const detectedUsername = username || await this.detectUsername();
+    
+    if (!detectedUsername) {
+      return null;
+    }
+
+    const workspacePath = path.join(projectPath, this.workspaceBaseDir, detectedUsername);
+    const exists = await fs.pathExists(workspacePath);
+    
+    return exists ? workspacePath : null;
+  }
+
+  /**
+   * 检查是否启用多用户模式
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @returns {Promise<boolean>} 是否启用多用户模式
+   */
+  async isMultiUserMode(projectPath) {
+    const workspaceBasePath = path.join(projectPath, this.workspaceBaseDir);
+    
+    // 检查 workspace 目录是否存在
+    const exists = await fs.pathExists(workspaceBasePath);
+    if (!exists) {
+      return false;
+    }
+
+    // 检查是否有用户子目录
+    try {
+      const entries = await fs.readdir(workspaceBasePath, { withFileTypes: true });
+      const userDirs = entries.filter(entry => 
+        entry.isDirectory() && !entry.name.startsWith('.')
+      );
+      
+      return userDirs.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * 列出所有用户工作区
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @returns {Promise<Array<string>>} 用户名列表
+   */
+  async listWorkspaces(projectPath) {
+    const workspaceBasePath = path.join(projectPath, this.workspaceBaseDir);
+    
+    const exists = await fs.pathExists(workspaceBasePath);
+    if (!exists) {
+      return [];
+    }
+
+    try {
+      const entries = await fs.readdir(workspaceBasePath, { withFileTypes: true });
+      const usernames = entries
+        .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+        .map(entry => entry.name);
+      
+      return usernames;
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * 确保 workspace .gitignore 存在
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @returns {Promise<boolean>} 是否成功
+   */
+  async ensureGitignore(projectPath) {
+    const workspaceBasePath = path.join(projectPath, this.workspaceBaseDir);
+    const gitignorePath = path.join(workspaceBasePath, '.gitignore');
+
+    try {
+      await fs.ensureDir(workspaceBasePath);
+      
+      const exists = await fs.pathExists(gitignorePath);
+      if (!exists) {
+        await fs.writeFile(gitignorePath, this.gitignoreContent, 'utf8');
+      }
+      
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * 读取工作区状态
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {string} username - 用户名（可选，自动检测）
+   * @returns {Promise<Object|null>} 工作区状态或 null
+   */
+  async readWorkspaceState(projectPath, username = null) {
+    const workspacePath = await this.getWorkspacePath(projectPath, username);
+    
+    if (!workspacePath) {
+      return null;
+    }
+
+    const taskStatePath = path.join(workspacePath, 'task-state.json');
+    
+    try {
+      const exists = await fs.pathExists(taskStatePath);
+      if (!exists) {
+        return null;
+      }
+
+      const content = await fs.readFile(taskStatePath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * 写入工作区状态
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {Object} state - 工作区状态
+   * @param {string} username - 用户名（可选，自动检测）
+   * @returns {Promise<boolean>} 是否成功
+   */
+  async writeWorkspaceState(projectPath, state, username = null) {
+    const workspacePath = await this.getWorkspacePath(projectPath, username);
+    
+    if (!workspacePath) {
+      return false;
+    }
+
+    const taskStatePath = path.join(workspacePath, 'task-state.json');
+    
+    try {
+      await fs.writeFile(taskStatePath, JSON.stringify(state, null, 2), 'utf8');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * 生成 CURRENT_CONTEXT.md 模板
+   * 
+   * @param {string} username - 用户名
+   * @returns {string} 模板内容
+   */
+  generateContextTemplate(username) {
+    return `# Personal Context - ${username}
+
+> **Note**: This is your personal context file. It is not shared with other team members.
+
+---
+
+## 🎯 Current Status
+
+**Status**: 🔥 Active  
+**Current Spec**: None  
+**Last Updated**: ${new Date().toISOString().split('T')[0]}
+
+---
+
+## 📝 Current Work
+
+**What I'm working on**:
+- (Add your current tasks here)
+
+**Next Steps**:
+- (Add your next steps here)
+
+---
+
+## 💡 Notes
+
+**Important Information**:
+- (Add important notes here)
+
+**Blockers**:
+- (Add any blockers here)
+
+---
+
+## 📋 Task Tracking
+
+**Claimed Tasks**:
+- (Tasks you've claimed will appear here)
+
+**Completed Tasks**:
+- (Completed tasks will appear here)
+
+---
+
+**Version**: 1.0  
+**Created**: ${new Date().toISOString()}  
+**Owner**: ${username}
+`;
+  }
+
+  /**
+   * 获取工作区信息
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {string} username - 用户名（可选，自动检测）
+   * @returns {Promise<Object|null>} 工作区信息或 null
+   */
+  async getWorkspaceInfo(projectPath, username = null) {
+    const detectedUsername = username || await this.detectUsername();
+    
+    if (!detectedUsername) {
+      return null;
+    }
+
+    const workspacePath = await this.getWorkspacePath(projectPath, detectedUsername);
+    
+    if (!workspacePath) {
+      return {
+        exists: false,
+        username: detectedUsername,
+        path: null
+      };
+    }
+
+    const state = await this.readWorkspaceState(projectPath, detectedUsername);
+    
+    return {
+      exists: true,
+      username: detectedUsername,
+      path: workspacePath,
+      state
+    };
+  }
+}
+
+module.exports = WorkspaceManager;

package/lib/workspace/workspace-sync.js

@@ -0,0 +1,356 @@
+const fs = require('fs-extra');
+const path = require('path');
+const TaskClaimer = require('../task/task-claimer');
+const WorkspaceManager = require('./workspace-manager');
+
+/**
+ * WorkspaceSync - 工作区同步
+ * 
+ * 协调个人工作区状态和共享任务状态
+ */
+class WorkspaceSync {
+  constructor() {
+    this.taskClaimer = new TaskClaimer();
+    this.workspaceManager = new WorkspaceManager();
+  }
+
+  /**
+   * 同步工作区
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {string} username - 用户名（可选，自动检测）
+   * @returns {Promise<Object>} 同步结果
+   */
+  async syncWorkspace(projectPath, username = null) {
+    try {
+      // 检测用户名
+      const detectedUsername = username || await this.workspaceManager.detectUsername();
+      
+      if (!detectedUsername) {
+        return {
+          success: false,
+          error: 'Could not detect username'
+        };
+      }
+
+      // 检查工作区是否存在
+      const workspacePath = await this.workspaceManager.getWorkspacePath(projectPath, detectedUsername);
+      
+      if (!workspacePath) {
+        return {
+          success: false,
+          error: 'Workspace not initialized. Run: kse workspace init'
+        };
+      }
+
+      // 读取个人工作区状态
+      const workspaceState = await this.workspaceManager.readWorkspaceState(projectPath, detectedUsername);
+      
+      if (!workspaceState) {
+        return {
+          success: false,
+          error: 'Could not read workspace state'
+        };
+      }
+
+      // 获取所有 Spec
+      const specsPath = path.join(projectPath, '.kiro/specs');
+      const specsExist = await fs.pathExists(specsPath);
+      
+      if (!specsExist) {
+        return {
+          success: true,
+          username: detectedUsername,
+          conflicts: [],
+          synced: 0,
+          message: 'No specs to sync'
+        };
+      }
+
+      const entries = await fs.readdir(specsPath, { withFileTypes: true });
+      const specDirs = entries.filter(entry => entry.isDirectory() && !entry.name.startsWith('.'));
+
+      // 同步每个 Spec
+      const conflicts = [];
+      let syncedCount = 0;
+
+      for (const specDir of specDirs) {
+        const specName = specDir.name;
+        const syncResult = await this.syncSpec(projectPath, specName, detectedUsername, workspaceState);
+        
+        if (syncResult.conflicts.length > 0) {
+          conflicts.push(...syncResult.conflicts);
+        }
+        
+        if (syncResult.synced) {
+          syncedCount++;
+        }
+      }
+
+      // 更新同步时间
+      workspaceState.lastSyncAt = new Date().toISOString();
+      await this.workspaceManager.writeWorkspaceState(projectPath, workspaceState, detectedUsername);
+
+      // 记录同步日志
+      await this.logSync(projectPath, detectedUsername, {
+        timestamp: new Date().toISOString(),
+        specs: syncedCount,
+        conflicts: conflicts.length,
+        success: conflicts.length === 0
+      });
+
+      return {
+        success: true,
+        username: detectedUsername,
+        conflicts,
+        synced: syncedCount,
+        message: conflicts.length > 0 
+          ? `Synced with ${conflicts.length} conflict(s)` 
+          : `Synced ${syncedCount} spec(s) successfully`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * 同步单个 Spec
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {string} specName - Spec 名称
+   * @param {string} username - 用户名
+   * @param {Object} workspaceState - 工作区状态
+   * @returns {Promise<Object>} 同步结果
+   */
+  async syncSpec(projectPath, specName, username, workspaceState) {
+    const conflicts = [];
+    let synced = false;
+
+    try {
+      // 读取共享任务状态
+      const tasksPath = path.join(projectPath, '.kiro/specs', specName, 'tasks.md');
+      const tasksExist = await fs.pathExists(tasksPath);
+      
+      if (!tasksExist) {
+        return { conflicts, synced: false };
+      }
+
+      const tasks = await this.taskClaimer.parseTasks(tasksPath);
+
+      // 获取个人任务状态
+      const personalTaskState = workspaceState.taskState[specName] || {};
+
+      // 检测冲突
+      for (const task of tasks) {
+        const personalState = personalTaskState[task.taskId];
+        
+        if (!personalState) {
+          continue;
+        }
+
+        // 检查状态冲突
+        if (personalState.status !== task.status) {
+          // 如果任务被当前用户认领，个人状态优先
+          if (task.claimedBy === username) {
+            // 更新共享状态为个人状态
+            await this.taskClaimer.updateTaskStatus(
+              projectPath,
+              specName,
+              task.taskId,
+              personalState.status
+            );
+            synced = true;
+          } else {
+            // 冲突：任务被其他人认领或状态不一致
+            conflicts.push({
+              specName,
+              taskId: task.taskId,
+              taskTitle: task.title,
+              personalStatus: personalState.status,
+              sharedStatus: task.status,
+              claimedBy: task.claimedBy,
+              type: task.claimedBy ? 'claimed-by-other' : 'status-mismatch'
+            });
+          }
+        }
+      }
+
+      // 更新个人状态为共享状态（对于未认领的任务）
+      for (const task of tasks) {
+        if (!task.claimedBy || task.claimedBy !== username) {
+          if (!workspaceState.taskState[specName]) {
+            workspaceState.taskState[specName] = {};
+          }
+          
+          workspaceState.taskState[specName][task.taskId] = {
+            status: task.status,
+            claimedAt: task.claimedAt,
+            completedAt: task.status === 'completed' ? new Date().toISOString() : null
+          };
+        }
+      }
+
+      return { conflicts, synced };
+    } catch (error) {
+      return { conflicts, synced: false };
+    }
+  }
+
+  /**
+   * 解决冲突
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {Object} conflict - 冲突对象
+   * @param {string} resolution - 解决策略 ('keep-local' | 'keep-remote' | 'merge')
+   * @param {string} username - 用户名
+   * @returns {Promise<Object>} 解决结果
+   */
+  async resolveConflict(projectPath, conflict, resolution, username) {
+    try {
+      const { specName, taskId, personalStatus, sharedStatus } = conflict;
+
+      if (resolution === 'keep-local') {
+        // 使用个人状态更新共享状态
+        const result = await this.taskClaimer.updateTaskStatus(
+          projectPath,
+          specName,
+          taskId,
+          personalStatus
+        );
+        
+        return {
+          success: result.success,
+          resolution: 'keep-local',
+          finalStatus: personalStatus
+        };
+      } else if (resolution === 'keep-remote') {
+        // 使用共享状态更新个人状态
+        const workspaceState = await this.workspaceManager.readWorkspaceState(projectPath, username);
+        
+        if (!workspaceState.taskState[specName]) {
+          workspaceState.taskState[specName] = {};
+        }
+        
+        workspaceState.taskState[specName][taskId] = {
+          status: sharedStatus,
+          claimedAt: null,
+          completedAt: sharedStatus === 'completed' ? new Date().toISOString() : null
+        };
+        
+        await this.workspaceManager.writeWorkspaceState(projectPath, workspaceState, username);
+        
+        return {
+          success: true,
+          resolution: 'keep-remote',
+          finalStatus: sharedStatus
+        };
+      } else if (resolution === 'merge') {
+        // 合并策略：如果任一状态为 completed，使用 completed
+        const finalStatus = personalStatus === 'completed' || sharedStatus === 'completed'
+          ? 'completed'
+          : personalStatus === 'in-progress' || sharedStatus === 'in-progress'
+          ? 'in-progress'
+          : 'not-started';
+        
+        // 更新共享状态
+        await this.taskClaimer.updateTaskStatus(projectPath, specName, taskId, finalStatus);
+        
+        // 更新个人状态
+        const workspaceState = await this.workspaceManager.readWorkspaceState(projectPath, username);
+        
+        if (!workspaceState.taskState[specName]) {
+          workspaceState.taskState[specName] = {};
+        }
+        
+        workspaceState.taskState[specName][taskId] = {
+          status: finalStatus,
+          claimedAt: null,
+          completedAt: finalStatus === 'completed' ? new Date().toISOString() : null
+        };
+        
+        await this.workspaceManager.writeWorkspaceState(projectPath, workspaceState, username);
+        
+        return {
+          success: true,
+          resolution: 'merge',
+          finalStatus
+        };
+      }
+      
+      return {
+        success: false,
+        error: 'Invalid resolution strategy'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * 记录同步日志
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {string} username - 用户名
+   * @param {Object} syncInfo - 同步信息
+   * @returns {Promise<boolean>} 是否成功
+   */
+  async logSync(projectPath, username, syncInfo) {
+    try {
+      const workspacePath = await this.workspaceManager.getWorkspacePath(projectPath, username);
+      
+      if (!workspacePath) {
+        return false;
+      }
+
+      const logPath = path.join(workspacePath, 'sync.log');
+      const logEntry = `[${syncInfo.timestamp}] Synced ${syncInfo.specs} spec(s), ${syncInfo.conflicts} conflict(s), success: ${syncInfo.success}\n`;
+      
+      await fs.appendFile(logPath, logEntry, 'utf8');
+      
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * 读取同步日志
+   * 
+   * @param {string} projectPath - 项目根目录路径
+   * @param {string} username - 用户名
+   * @param {number} lines - 读取行数（默认 10）
+   * @returns {Promise<Array>} 日志条目
+   */
+  async readSyncLog(projectPath, username, lines = 10) {
+    try {
+      const workspacePath = await this.workspaceManager.getWorkspacePath(projectPath, username);
+      
+      if (!workspacePath) {
+        return [];
+      }
+
+      const logPath = path.join(workspacePath, 'sync.log');
+      const exists = await fs.pathExists(logPath);
+      
+      if (!exists) {
+        return [];
+      }
+
+      const content = await fs.readFile(logPath, 'utf8');
+      const allLines = content.trim().split('\n').filter(line => line);
+      
+      // 返回最后 N 行
+      return allLines.slice(-lines);
+    } catch (error) {
+      return [];
+    }
+  }
+}
+
+module.exports = WorkspaceSync;