kiro-spec-engine 1.0.0

package/template/.kiro/tools/ultrawork_enhancer.py

@@ -0,0 +1,676 @@
+#!/usr/bin/env python3
+"""
+Ultrawork Enhancer - 为 Kiro Spec 体系注入 Sisyphus 的不懈努力精神
+
+核心理念: 像西西弗斯推石上山一样,永不放弃,不懈努力,直到任务完美完成
+"""
+
+import re
+import os
+from pathlib import Path
+from typing import List, Dict, Tuple, Optional
+
+
+class UltraworkEnhancer:
+    """
+    Ultrawork 增强器 - 在 Kiro Spec 体系中实现 Sisyphus 的不懈努力精神
+    
+    不是替代现有工具,而是增强执行质量和完成度
+    """
+    
+    def __init__(self):
+        self.quality_threshold = 9.0  # 专业级质量标准 (0-10)
+        self.max_iterations = 10      # 防止无限循环
+        self.improvement_log = []     # 记录改进过程
+        self.language = None          # 文档语言 (zh/en), 自动检测
+    
+    # ==================== 语言检测 ====================
+    
+    def _detect_language(self, content: str) -> str:
+        """
+        检测文档语言
+        返回: 'zh' (中文) 或 'en' (英文)
+        """
+        # 统计中文字符数量
+        chinese_chars = len(re.findall(r'[\u4e00-\u9fff]', content))
+        # 统计英文单词数量
+        english_words = len(re.findall(r'\b[a-zA-Z]+\b', content))
+        
+        # 如果中文字符超过100个，判定为中文
+        if chinese_chars > 100:
+            return 'zh'
+        # 如果英文单词超过中文字符的3倍，判定为英文
+        elif english_words > chinese_chars * 3:
+            return 'en'
+        # 默认中文
+        return 'zh'
+    
+    # ==================== Requirements 阶段 Ultrawork ====================
+    
+    def enhance_requirements_quality(self, requirements_path: str) -> Dict:
+        """
+        Requirements 阶段的 Ultrawork 增强
+        
+        像资深产品经理一样深入思考每个用户场景
+        """
+        print("🔥 启动 Requirements 阶段 Ultrawork 增强...")
+        
+        if not os.path.exists(requirements_path):
+            return {"error": "Requirements 文件不存在"}
+        
+        with open(requirements_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # 检测语言
+        self.language = self._detect_language(content)
+        print(f"📝 检测到文档语言: {'中文' if self.language == 'zh' else 'English'}")
+        
+        # 评估当前质量
+        quality_score = self._assess_requirements_quality(content)
+        print(f"📊 Requirements 质量评分: {quality_score}/10")
+        
+        if quality_score >= self.quality_threshold:
+            print("✅ Requirements 已达到专业级标准! Ultrawork 精神得到体现!")
+            return {
+                "success": True,
+                "iterations": 0,
+                "final_quality_score": quality_score,
+                "message": "文档质量已达到专业级标准,无需进一步改进"
+            }
+        
+        iteration = 0
+        original_content = content
+        
+        while iteration < self.max_iterations:
+            # 识别改进点
+            improvements = self._identify_requirements_improvements(content)
+            
+            if not improvements:
+                print("⚠️ 无法识别更多改进点,停止迭代")
+                break
+            
+            # 应用改进 (Ultrawork 精神: 不懈努力)
+            content = self._apply_requirements_improvements(content, improvements)
+            iteration += 1
+            
+            # 重新评估质量
+            new_quality_score = self._assess_requirements_quality(content)
+            
+            # 记录改进过程
+            self.improvement_log.append({
+                "stage": "requirements",
+                "iteration": iteration,
+                "improvements": improvements,
+                "quality_score": new_quality_score
+            })
+            
+            print(f"🔄 第 {iteration} 轮改进: {', '.join(improvements)}")
+            print(f"📊 改进后质量评分: {new_quality_score}/10")
+            
+            # 检查是否达到质量标准
+            if new_quality_score >= self.quality_threshold:
+                print("✅ Requirements 已达到专业级标准!")
+                break
+            
+            # 检查是否有实际改进
+            if new_quality_score <= quality_score:
+                print("⚠️ 质量评分未提升,停止迭代")
+                break
+            
+            quality_score = new_quality_score
+        
+        # 如果有改进,更新文件
+        if content != original_content:
+            with open(requirements_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            print(f"📝 Requirements 已更新,共进行 {iteration} 轮 Ultrawork 改进")
+        
+        return {
+            "success": True,
+            "iterations": iteration,
+            "final_quality_score": self._assess_requirements_quality(content),
+            "improvements_applied": self.improvement_log
+        }
+    
+    def _assess_requirements_quality(self, content: str) -> float:
+        """评估 Requirements 文档质量 (0-10) - 支持中英文"""
+        score = 0.0
+        lang = self.language or self._detect_language(content)
+        
+        if lang == 'zh':
+            # 中文评分标准
+            # 基础结构检查 (2分)
+            if "## 1. 概述" in content or "## Introduction" in content: score += 0.5
+            if "## 2. 用户故事" in content: score += 0.5
+            if "## 3. 功能需求" in content: score += 0.5
+            if "## 4. 非功能需求" in content: score += 0.5
+            
+            # EARS 格式检查 (2分)
+            ears_patterns = len(re.findall(r'WHEN.*THEN', content, re.IGNORECASE))
+            score += min(ears_patterns * 0.2, 2.0)
+            
+            # 用户故事质量 (2分)
+            user_story_patterns = len(re.findall(r'作为.*我希望.*以便', content))
+            score += min(user_story_patterns * 0.3, 2.0)
+            
+            # 验收标准完整性 (2分)
+            acceptance_criteria = len(re.findall(r'\*\*验收标准\*\*:', content))
+            score += min(acceptance_criteria * 0.4, 2.0)
+            
+            # 非功能需求覆盖 (1分)
+            nfr_keywords = ['性能', '安全', '可用性', '可维护性', '兼容性']
+            nfr_coverage = sum(1 for keyword in nfr_keywords if keyword in content)
+            score += min(nfr_coverage * 0.2, 1.0)
+            
+            # 约束条件 (1分)
+            if "约束条件" in content or "限制" in content:
+                score += 1.0
+        else:
+            # 英文评分标准
+            # 基础结构检查 (2分)
+            if "## Introduction" in content or "## Overview" in content: score += 0.5
+            if "## Glossary" in content or "## Terminology" in content: score += 0.5
+            if "## Requirements" in content or "## Functional Requirements" in content: score += 0.5
+            if "Non-functional" in content or "Non-Functional" in content: score += 0.5
+            
+            # EARS 格式检查 (2分)
+            ears_patterns = len(re.findall(r'WHEN.*THEN|IF.*THEN', content, re.IGNORECASE))
+            score += min(ears_patterns * 0.15, 2.0)
+            
+            # 用户故事质量 (2分)
+            user_story_patterns = len(re.findall(r'As a.*I want.*So that', content, re.IGNORECASE))
+            score += min(user_story_patterns * 0.25, 2.0)
+            
+            # 验收标准完整性 (2分)
+            acceptance_criteria = len(re.findall(r'Acceptance Criteria|#### Acceptance Criteria', content, re.IGNORECASE))
+            score += min(acceptance_criteria * 0.3, 2.0)
+            
+            # 非功能需求覆盖 (1分)
+            nfr_keywords = ['performance', 'security', 'usability', 'maintainability', 'compatibility', 'scalability']
+            nfr_coverage = sum(1 for keyword in nfr_keywords if keyword.lower() in content.lower())
+            score += min(nfr_coverage * 0.15, 1.0)
+            
+            # 约束条件 (1分)
+            if "constraint" in content.lower() or "limitation" in content.lower():
+                score += 1.0
+        
+        return min(score, 10.0)
+    
+    def _identify_requirements_improvements(self, content: str) -> List[str]:
+        """识别 Requirements 文档的改进点 - 支持中英文"""
+        improvements = []
+        lang = self.language or self._detect_language(content)
+        
+        if lang == 'zh':
+            # 中文改进建议
+            if "## 1. 概述" not in content and "## Introduction" not in content:
+                improvements.append("添加项目概述章节")
+            
+            if "## 2. 用户故事" not in content:
+                improvements.append("添加用户故事章节")
+            
+            if "## 4. 非功能需求" not in content:
+                improvements.append("添加非功能需求章节")
+            
+            # 检查 EARS 格式
+            if len(re.findall(r'WHEN.*THEN', content, re.IGNORECASE)) < 5:
+                improvements.append("增加更多 EARS 格式的验收标准 (WHEN...THEN)")
+            
+            # 检查用户故事格式
+            if len(re.findall(r'作为.*我希望.*以便', content)) < 3:
+                improvements.append("完善用户故事格式 (作为...我希望...以便)")
+            
+            # 检查非功能需求覆盖
+            nfr_keywords = ['性能需求', '安全需求', '可用性需求', '可维护性需求']
+            missing_nfr = []
+            for kw in nfr_keywords:
+                if kw not in content:
+                    missing_nfr.append(kw.replace('需求', ''))
+            
+            if missing_nfr and "## 4. 非功能需求" in content:
+                improvements.append(f"补充非功能需求: {', '.join(missing_nfr)}")
+        else:
+            # 英文改进建议
+            if "## Introduction" not in content and "## Overview" not in content:
+                improvements.append("Add Introduction or Overview section")
+            
+            if "## Glossary" not in content and "## Terminology" not in content:
+                improvements.append("Add Glossary section to define key terms")
+            
+            if "User Story" not in content and "user story" not in content:
+                improvements.append("Add User Stories section")
+            
+            # 检查 EARS 格式
+            ears_count = len(re.findall(r'WHEN.*THEN|IF.*THEN', content, re.IGNORECASE))
+            if ears_count < 5:
+                improvements.append(f"Add more EARS-format acceptance criteria (currently {ears_count}, target 5+)")
+            
+            # 检查用户故事格式
+            user_story_count = len(re.findall(r'As a.*I want.*So that', content, re.IGNORECASE))
+            if user_story_count < 3:
+                improvements.append(f"Add more user stories in 'As a...I want...So that' format (currently {user_story_count}, target 3+)")
+            
+            # 检查非功能需求
+            nfr_keywords = ['performance', 'security', 'usability', 'maintainability', 'scalability']
+            missing_nfr = [kw for kw in nfr_keywords if kw.lower() not in content.lower()]
+            
+            if missing_nfr and len(missing_nfr) > 2:
+                improvements.append(f"Add non-functional requirements: {', '.join(missing_nfr[:3])}")
+        
+        return improvements
+    
+    def _apply_requirements_improvements(self, content: str, improvements: List[str]) -> str:
+        """应用 Requirements 改进 (这里是示例,实际需要更复杂的逻辑)"""
+        # 这里只是示例实现,实际应该根据具体改进点进行相应修改
+        improved_content = content
+        
+        for improvement in improvements:
+            if "添加非功能需求章节" in improvement:
+                if "## 4. 非功能需求" not in improved_content:
+                    improved_content += "\n\n## 4. 非功能需求\n\n### 4.1 性能需求\n- 系统响应时间应小于 2 秒\n\n### 4.2 安全需求\n- 用户数据必须加密存储\n\n### 4.3 可用性需求\n- 系统可用性应达到 99.9%\n"
+        
+        return improved_content
+    
+    # ==================== Design 阶段 Ultrawork ====================
+    
+    def enhance_design_completeness(self, design_path: str, requirements_path: str) -> Dict:
+        """
+        Design 阶段的 Ultrawork 增强
+        
+        像资深架构师一样设计每个组件
+        """
+        print("🔥 启动 Design 阶段 Ultrawork 增强...")
+        
+        if not os.path.exists(design_path):
+            return {"error": "Design 文件不存在"}
+        
+        if not os.path.exists(requirements_path):
+            return {"error": "Requirements 文件不存在,无法进行双向追溯"}
+        
+        with open(design_path, 'r', encoding='utf-8') as f:
+            design_content = f.read()
+        
+        with open(requirements_path, 'r', encoding='utf-8') as f:
+            requirements_content = f.read()
+        
+        # 检测语言
+        self.language = self._detect_language(design_content)
+        print(f"📝 检测到文档语言: {'中文' if self.language == 'zh' else 'English'}")
+        
+        iteration = 0
+        original_content = design_content
+        
+        while iteration < self.max_iterations:
+            # 评估当前质量
+            quality_score = self._assess_design_quality(design_content, requirements_content)
+            print(f"📊 Design 质量评分: {quality_score}/10")
+            
+            if quality_score >= self.quality_threshold:
+                print("✅ Design 已达到专业级标准!")
+                break
+            
+            # 识别改进点
+            improvements = self._identify_design_improvements(design_content, requirements_content)
+            
+            if not improvements:
+                print("⚠️ 无法识别更多改进点,停止迭代")
+                break
+            
+            # 应用改进 (Ultrawork 精神: 不懈努力)
+            design_content = self._apply_design_improvements(design_content, improvements)
+            iteration += 1
+            
+            # 记录改进过程
+            self.improvement_log.append({
+                "stage": "design",
+                "iteration": iteration,
+                "improvements": improvements,
+                "quality_score": quality_score
+            })
+            
+            print(f"🔄 第 {iteration} 轮改进: {', '.join(improvements)}")
+        
+        # 如果有改进,更新文件
+        if design_content != original_content:
+            with open(design_path, 'w', encoding='utf-8') as f:
+                f.write(design_content)
+            print(f"📝 Design 已更新,共进行 {iteration} 轮 Ultrawork 改进")
+        
+        return {
+            "success": True,
+            "iterations": iteration,
+            "final_quality_score": self._assess_design_quality(design_content, requirements_content),
+            "improvements_applied": self.improvement_log
+        }
+    
+    def _assess_design_quality(self, design_content: str, requirements_content: str) -> float:
+        """评估 Design 文档质量 (0-10) - 支持中英文"""
+        score = 0.0
+        lang = self.language or self._detect_language(design_content)
+        
+        if lang == 'zh':
+            # 中文评分标准
+            # 基础结构检查 (2分)
+            if "## 1. 系统概述" in design_content or "## 1. 概述" in design_content or "## Overview" in design_content: score += 0.5
+            if "## 2. 架构设计" in design_content or "## Architecture" in design_content: score += 0.5
+            if "## 3. 组件设计" in design_content or "## Components" in design_content: score += 0.5
+            if "## 4. 数据流设计" in design_content or "## 4. 接口设计" in design_content: score += 0.5
+            
+            # 需求追溯性检查 (2分)
+            req_references = len(re.findall(r'需求\s*\d+\.\d+|Requirements?\s*\d+\.\d+|Requirement\s+\d+\.\d+', design_content, re.IGNORECASE))
+            score += min(req_references * 0.2, 2.0)
+            
+            # 架构图和设计图 (1.5分)
+            diagram_indicators = len(re.findall(r'```mermaid|```plantuml|架构图|设计图|流程图', design_content))
+            score += min(diagram_indicators * 0.5, 1.5)
+            
+            # 技术选型说明 (1.5分)
+            tech_keywords = ['技术选型', '技术栈', '框架选择', '数据库', 'API', '协议']
+            tech_coverage = sum(1 for keyword in tech_keywords if keyword in design_content)
+            score += min(tech_coverage * 0.25, 1.5)
+            
+            # 非功能需求设计 (1.5分)
+            nfr_design = ['性能设计', '安全设计', '可扩展性', '容错机制', '监控']
+            nfr_coverage = sum(1 for keyword in nfr_design if keyword in design_content)
+            score += min(nfr_coverage * 0.3, 1.5)
+            
+            # 接口定义完整性 (1.5分)
+            interface_indicators = len(re.findall(r'接口定义|API\s*设计|数据结构|参数说明', design_content))
+            score += min(interface_indicators * 0.4, 1.5)
+        else:
+            # 英文评分标准
+            # 基础结构检查 (2分)
+            if "## Overview" in design_content or "## Introduction" in design_content: score += 0.5
+            if "## Architecture" in design_content or "## System Architecture" in design_content: score += 0.5
+            if "## Components" in design_content or "## Component" in design_content: score += 0.5
+            if "## Interface" in design_content or "## Data Flow" in design_content or "## API" in design_content: score += 0.5
+            
+            # 需求追溯性检查 (2分)
+            req_references = len(re.findall(r'Requirement[s]?\s+\d+\.\d+|_Requirements:\s+\d+\.\d+|Validates:\s+Requirements?\s+\d+\.\d+', design_content, re.IGNORECASE))
+            score += min(req_references * 0.15, 2.0)
+            
+            # 架构图和设计图 (1.5分)
+            diagram_indicators = len(re.findall(r'```mermaid|```plantuml|```diagram|Architecture Diagram|Component Diagram', design_content, re.IGNORECASE))
+            score += min(diagram_indicators * 0.4, 1.5)
+            
+            # 技术选型说明 (1.5分)
+            tech_keywords = ['technology', 'framework', 'database', 'api', 'protocol', 'stack', 'library']
+            tech_coverage = sum(1 for keyword in tech_keywords if keyword.lower() in design_content.lower())
+            score += min(tech_coverage * 0.2, 1.5)
+            
+            # 非功能需求设计 (1.5分)
+            nfr_design = ['performance', 'security', 'scalability', 'fault tolerance', 'monitoring', 'error handling']
+            nfr_coverage = sum(1 for keyword in nfr_design if keyword.lower() in design_content.lower())
+            score += min(nfr_coverage * 0.25, 1.5)
+            
+            # 接口定义完整性 (1.5分)
+            interface_indicators = len(re.findall(r'Interface|API\s+Design|Data\s+Model|Data\s+Structure|Parameter', design_content, re.IGNORECASE))
+            score += min(interface_indicators * 0.3, 1.5)
+        
+        return min(score, 10.0)
+    
+    def _identify_design_improvements(self, design_content: str, requirements_content: str) -> List[str]:
+        """识别 Design 文档的改进点"""
+        improvements = []
+        
+        # 检查基础结构
+        if "## 1. 系统概述" not in design_content and "## 1. 概述" not in design_content:
+            improvements.append("添加系统概述章节")
+        
+        if "## 2. 架构设计" not in design_content:
+            improvements.append("添加架构设计章节")
+        
+        if "## 3. 组件设计" not in design_content:
+            improvements.append("添加组件设计章节")
+        
+        # 检查需求追溯
+        req_references = len(re.findall(r'需求\s*\d+\.\d+|Requirements?\s*\d+\.\d+', design_content))
+        if req_references < 3:
+            improvements.append("增加需求到设计的双向追溯")
+        
+        # 检查架构图
+        if "```mermaid" not in design_content and "架构图" not in design_content:
+            improvements.append("添加架构图或设计图")
+        
+        # 检查技术选型
+        tech_keywords = ['技术选型', '技术栈', '框架选择']
+        if not any(keyword in design_content for keyword in tech_keywords):
+            improvements.append("补充技术选型说明")
+        
+        # 检查非功能需求设计
+        nfr_design = ['性能设计', '安全设计', '可扩展性']
+        missing_nfr = [nfr for nfr in nfr_design if nfr not in design_content]
+        if missing_nfr:
+            improvements.append(f"补充非功能需求设计: {', '.join(missing_nfr)}")
+        
+        return improvements
+    
+    def _apply_design_improvements(self, content: str, improvements: List[str]) -> str:
+        """应用 Design 改进"""
+        improved_content = content
+        
+        for improvement in improvements:
+            if "添加架构图或设计图" in improvement:
+                if "```mermaid" not in improved_content:
+                    improved_content += "\n\n### 系统架构图\n\n```mermaid\ngraph TB\n    A[用户界面] --> B[业务逻辑层]\n    B --> C[数据访问层]\n    C --> D[数据存储]\n```\n"
+            
+            if "补充技术选型说明" in improvement:
+                if "技术选型" not in improved_content:
+                    improved_content += "\n\n## 技术选型\n\n### 核心技术栈\n- 前端: React/Vue.js\n- 后端: Node.js/Python\n- 数据库: PostgreSQL/MongoDB\n- 缓存: Redis\n\n### 选型理由\n- 考虑团队技术栈熟悉度\n- 满足性能和扩展性要求\n- 社区支持和生态完善\n"
+        
+        return improved_content
+    
+    # ==================== Tasks 阶段 Ultrawork ====================
+    
+    def enhance_task_execution(self, tasks_path: str) -> Dict:
+        """
+        Tasks 阶段的 Ultrawork 增强
+        
+        像资深开发者一样实现每行代码,遇到困难不放弃
+        """
+        print("🔥 启动 Tasks 阶段 Ultrawork 增强...")
+        
+        if not os.path.exists(tasks_path):
+            return {"error": "Tasks 文件不存在"}
+        
+        with open(tasks_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # 分析任务完成情况
+        task_analysis = self._analyze_task_completion(content)
+        
+        if task_analysis['incomplete_count'] == 0:
+            return {
+                "success": True,
+                "message": "✅ 所有任务已完成! Ultrawork 精神得到完美体现!",
+                "task_analysis": task_analysis
+            }
+        
+        print(f"📋 任务完成情况分析:")
+        print(f"  - 总任务数: {task_analysis['total_count']}")
+        print(f"  - 已完成: {task_analysis['completed_count']}")
+        print(f"  - 进行中: {task_analysis['in_progress_count']}")
+        print(f"  - 未开始: {task_analysis['not_started_count']}")
+        print(f"  - 完成率: {task_analysis['completion_rate']:.1f}%")
+        
+        # Ultrawork 精神: 不懈努力提醒
+        ultrawork_messages = self._generate_ultrawork_reminders(task_analysis)
+        
+        for message in ultrawork_messages:
+            print(f"🔥 {message}")
+        
+        # 识别阻塞任务和优先级
+        priority_tasks = self._identify_priority_tasks(task_analysis['incomplete_tasks'])
+        
+        return {
+            "success": True,
+            "message": f"发现 {task_analysis['incomplete_count']} 个未完成任务,需要继续推进",
+            "task_analysis": task_analysis,
+            "priority_tasks": priority_tasks,
+            "ultrawork_reminders": ultrawork_messages,
+            "next_actions": self._suggest_next_actions(task_analysis)
+        }
+    
+    def _analyze_task_completion(self, content: str) -> Dict:
+        """分析任务完成情况"""
+        # 匹配不同状态的任务
+        completed_tasks = re.findall(r'- \[x\] (.+)', content)
+        in_progress_tasks = re.findall(r'- \[-\] (.+)', content)
+        not_started_tasks = re.findall(r'- \[ \] (.+)', content)
+        queued_tasks = re.findall(r'- \[~\] (.+)', content)
+        
+        total_count = len(completed_tasks) + len(in_progress_tasks) + len(not_started_tasks) + len(queued_tasks)
+        completed_count = len(completed_tasks)
+        incomplete_count = len(in_progress_tasks) + len(not_started_tasks) + len(queued_tasks)
+        
+        completion_rate = (completed_count / total_count * 100) if total_count > 0 else 0
+        
+        return {
+            "total_count": total_count,
+            "completed_count": completed_count,
+            "completed_tasks": completed_tasks,
+            "in_progress_count": len(in_progress_tasks),
+            "in_progress_tasks": in_progress_tasks,
+            "not_started_count": len(not_started_tasks),
+            "not_started_tasks": not_started_tasks,
+            "queued_count": len(queued_tasks),
+            "queued_tasks": queued_tasks,
+            "incomplete_count": incomplete_count,
+            "incomplete_tasks": in_progress_tasks + not_started_tasks + queued_tasks,
+            "completion_rate": completion_rate
+        }
+    
+    def _generate_ultrawork_reminders(self, task_analysis: Dict) -> List[str]:
+        """生成 Ultrawork 精神提醒"""
+        reminders = []
+        
+        completion_rate = task_analysis['completion_rate']
+        
+        if completion_rate == 0:
+            reminders.append("Sisyphus 精神: 万事开头难,但永不放弃! 开始推动第一块石头!")
+        elif completion_rate < 30:
+            reminders.append("Sisyphus 精神: 石头刚开始滚动,保持动力,持续推进!")
+        elif completion_rate < 70:
+            reminders.append("Sisyphus 精神: 已经爬到半山腰,不能松懈,继续向山顶冲刺!")
+        elif completion_rate < 95:
+            reminders.append("Sisyphus 精神: 接近山顶了,最后的冲刺最关键,不懈努力!")
+        else:
+            reminders.append("Sisyphus 精神: 即将登顶,每个细节都要完美,追求卓越!")
+        
+        if task_analysis['in_progress_count'] > 0:
+            reminders.append(f"有 {task_analysis['in_progress_count']} 个任务正在进行中,保持专注,逐个击破!")
+        
+        if task_analysis['not_started_count'] > 3:
+            reminders.append("任务较多,但不要被数量吓倒,分解执行,每完成一个都是胜利!")
+        
+        return reminders
+    
+    def _identify_priority_tasks(self, incomplete_tasks: List[str]) -> List[Dict]:
+        """识别优先级任务"""
+        priority_tasks = []
+        
+        for i, task in enumerate(incomplete_tasks):
+            priority = "normal"
+            reasons = []
+            
+            # 基于关键词判断优先级
+            high_priority_keywords = ['基础', '核心', '关键', '重要', '阻塞', '依赖']
+            urgent_keywords = ['紧急', '立即', '马上', '优先']
+            
+            task_lower = task.lower()
+            
+            if any(keyword in task for keyword in high_priority_keywords):
+                priority = "high"
+                reasons.append("包含关键词")
+            
+            if any(keyword in task for keyword in urgent_keywords):
+                priority = "urgent"
+                reasons.append("标记为紧急")
+            
+            # 基于任务编号判断(假设编号小的更基础)
+            if re.match(r'^\d+\.\d+', task) and task.startswith(('1.', '2.')):
+                if priority == "normal":
+                    priority = "high"
+                reasons.append("基础任务")
+            
+            priority_tasks.append({
+                "task": task,
+                "priority": priority,
+                "reasons": reasons,
+                "index": i
+            })
+        
+        # 按优先级排序
+        priority_order = {"urgent": 0, "high": 1, "normal": 2}
+        priority_tasks.sort(key=lambda x: priority_order[x["priority"]])
+        
+        return priority_tasks
+    
+    def _suggest_next_actions(self, task_analysis: Dict) -> List[str]:
+        """建议下一步行动"""
+        suggestions = []
+        
+        if task_analysis['in_progress_count'] > 0:
+            suggestions.append("优先完成进行中的任务,避免任务切换成本")
+        
+        if task_analysis['not_started_count'] > 0:
+            suggestions.append("从最基础或最重要的未开始任务开始")
+        
+        if task_analysis['completion_rate'] < 50:
+            suggestions.append("建议专注于单个任务,避免并行过多任务")
+        else:
+            suggestions.append("可以考虑并行处理独立的任务以提高效率")
+        
+        suggestions.append("每完成一个任务立即更新状态,保持进度可见性")
+        suggestions.append("遇到困难时体现 Ultrawork 精神: 不放弃,寻找替代方案")
+        
+        return suggestions
+    
+    # ==================== 通用工具方法 ====================
+    
+    def get_improvement_log(self) -> List[Dict]:
+        """获取改进日志"""
+        return self.improvement_log
+    
+    def reset_log(self):
+        """重置改进日志"""
+        self.improvement_log = []
+    
+    def set_quality_threshold(self, threshold: float):
+        """设置质量阈值"""
+        self.quality_threshold = max(0.0, min(10.0, threshold))
+
+
+def main():
+    """命令行工具入口"""
+    import sys
+    
+    if len(sys.argv) < 2:
+        print("用法: python ultrawork_enhancer.py <command> [args]")
+        print("命令:")
+        print("  requirements <path>  - 增强 Requirements 文档质量")
+        print("  design <design_path> <requirements_path>  - 增强 Design 文档完整性")
+        print("  tasks <path>  - 检查 Tasks 完成情况")
+        return
+    
+    enhancer = UltraworkEnhancer()
+    command = sys.argv[1]
+    
+    if command == "requirements" and len(sys.argv) >= 3:
+        result = enhancer.enhance_requirements_quality(sys.argv[2])
+        print(f"结果: {result}")
+    
+    elif command == "design" and len(sys.argv) >= 4:
+        result = enhancer.enhance_design_completeness(sys.argv[2], sys.argv[3])
+        print(f"结果: {result}")
+    
+    elif command == "tasks" and len(sys.argv) >= 3:
+        result = enhancer.enhance_task_execution(sys.argv[2])
+        print(f"结果: {result}")
+    
+    else:
+        print("❌ 无效的命令或参数")
+
+
+if __name__ == "__main__":
+    main()