htmlgen-mcp 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

htmlgen_mcp/context_aware_executor.py

@@ -0,0 +1,262 @@
+"""上下文感知的执行器 - 确保 context_content 被正确使用"""
+import json
+from typing import Dict, Any, Optional
+
+
+class ContextAwareExecutor:
+    """确保上下文内容在执行过程中被正确传递和使用"""
+    
+    @staticmethod
+    def inject_context_to_tools(plan: Dict[str, Any], context_content: str) -> Dict[str, Any]:
+        """
+        将上下文内容注入到工具调用序列中
+        
+        Args:
+            plan: 执行计划
+            context_content: 上下文内容（如咖啡馆列表）
+            
+        Returns:
+            修改后的计划
+        """
+        if not context_content:
+            return plan
+            
+        # 获取工具序列
+        tools_sequence = plan.get("tools_sequence", [])
+        
+        # 遍历每个工具调用，注入上下文
+        for tool in tools_sequence:
+            tool_name = tool.get("tool", "")
+            
+            # 对于创建 HTML 文件的工具，注入具体内容
+            if tool_name == "create_html_file":
+                # 修改内容参数，确保包含实际数据
+                original_content = tool.get("parameters", {}).get("content", "")
+                
+                # 如果是主页面，替换内容
+                if "index.html" in tool.get("parameters", {}).get("file_name", ""):
+                    tool["parameters"]["content"] = generate_html_with_context(
+                        context_content,
+                        tool.get("parameters", {}).get("title", "网站")
+                    )
+                    
+            # 对于创建内容的工具，也要注入上下文
+            elif tool_name in ["add_content_section", "create_content", "add_text_content"]:
+                # 确保内容参数包含实际数据
+                tool["parameters"]["context_data"] = context_content
+                
+        return plan
+    
+    @staticmethod
+    def enhance_prompt_with_context(prompt: str, context_content: str) -> str:
+        """
+        增强提示词，明确要求使用上下文内容
+        
+        Args:
+            prompt: 原始提示词
+            context_content: 上下文内容
+            
+        Returns:
+            增强后的提示词
+        """
+        if not context_content:
+            return prompt
+            
+        enhanced = f"""
+{prompt}
+
+【重要：必须使用以下具体数据】
+以下是必须在网页中展示的实际内容，请完整地将这些信息整合到网页中：
+
+{context_content}
+
+要求：
+1. 必须将上述所有咖啡馆信息完整展示在网页中
+2. 使用卡片或列表形式展示每个咖啡馆
+3. 包含咖啡馆名称和地址
+4. 可以添加适当的样式和布局，但内容必须准确
+5. 不要生成虚构的内容，只使用提供的实际数据
+"""
+        return enhanced
+
+
+def generate_html_with_context(context_content: str, title: str = "咖啡馆指南") -> str:
+    """
+    根据上下文内容生成 HTML
+    
+    Args:
+        context_content: 咖啡馆列表等具体内容
+        title: 网站标题
+        
+    Returns:
+        完整的 HTML 内容
+    """
+    # 解析咖啡馆信息
+    cafes = []
+    lines = context_content.split('\n')
+    current_cafe = {}
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        # 识别咖啡馆名称（带序号的行）
+        if line[0].isdigit() and '. ' in line:
+            if current_cafe:
+                cafes.append(current_cafe)
+            # 提取咖啡馆名称
+            name = line.split('. ', 1)[1] if '. ' in line else line
+            current_cafe = {'name': name, 'address': ''}
+            
+        # 识别地址（- 开头的行）
+        elif line.startswith('- 地址：'):
+            if current_cafe:
+                current_cafe['address'] = line.replace('- 地址：', '').strip()
+                
+    # 添加最后一个咖啡馆
+    if current_cafe:
+        cafes.append(current_cafe)
+    
+    # 生成 HTML
+    cafe_cards = []
+    for cafe in cafes:
+        card = f'''
+            <div class="col-md-6 col-lg-4 mb-4">
+                <div class="card h-100 shadow-sm">
+                    <div class="card-body">
+                        <h5 class="card-title">
+                            <i class="bi bi-cup-hot-fill text-brown"></i> {cafe['name']}
+                        </h5>
+                        <p class="card-text">
+                            <i class="bi bi-geo-alt-fill text-muted"></i>
+                            <span class="text-muted">{cafe['address']}</span>
+                        </p>
+                        <a href="#" class="btn btn-outline-primary btn-sm">
+                            <i class="bi bi-map"></i> 查看地图
+                        </a>
+                    </div>
+                </div>
+            </div>'''
+        cafe_cards.append(card)
+    
+    html = f'''<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{title}</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.0/font/bootstrap-icons.css" rel="stylesheet">
+    <link href="assets/css/style.css" rel="stylesheet">
+    <style>
+        .text-brown {{ color: #6f4e37; }}
+        .hero-section {{
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 80px 0;
+        }}
+        .card {{
+            transition: transform 0.3s;
+            border-radius: 15px;
+        }}
+        .card:hover {{
+            transform: translateY(-5px);
+        }}
+    </style>
+</head>
+<body>
+    <!-- 导航栏 -->
+    <nav class="navbar navbar-expand-lg navbar-light bg-light shadow-sm">
+        <div class="container">
+            <a class="navbar-brand" href="#">
+                <i class="bi bi-cup-hot-fill text-brown"></i> {title}
+            </a>
+            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav">
+                <span class="navbar-toggler-icon"></span>
+            </button>
+            <div class="collapse navbar-collapse" id="navbarNav">
+                <ul class="navbar-nav ms-auto">
+                    <li class="nav-item">
+                        <a class="nav-link" href="#cafes">咖啡馆列表</a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link" href="#about">关于</a>
+                    </li>
+                </ul>
+            </div>
+        </div>
+    </nav>
+
+    <!-- Hero 区域 -->
+    <section class="hero-section text-center">
+        <div class="container">
+            <h1 class="display-4 fw-bold mb-4">{title}</h1>
+            <p class="lead mb-4">探索大族广场周边的精品咖啡馆</p>
+            <p class="mb-4">共收录 {len(cafes)} 家咖啡馆，均在步行范围内</p>
+            <a href="#cafes" class="btn btn-light btn-lg">
+                <i class="bi bi-arrow-down-circle"></i> 浏览咖啡馆
+            </a>
+        </div>
+    </section>
+
+    <!-- 咖啡馆列表 -->
+    <section id="cafes" class="py-5">
+        <div class="container">
+            <h2 class="text-center mb-5">咖啡馆列表</h2>
+            <div class="row">
+                {"".join(cafe_cards)}
+            </div>
+        </div>
+    </section>
+
+    <!-- 关于区域 -->
+    <section id="about" class="py-5 bg-light">
+        <div class="container">
+            <div class="row align-items-center">
+                <div class="col-md-6">
+                    <h2>关于本指南</h2>
+                    <p class="lead">为您精选大族广场附近的咖啡馆</p>
+                    <p>本指南收录了北京市大兴区大族广场周边1公里范围内的所有知名咖啡馆，包括星巴克、Peet's Coffee、M Stand等品牌，以及特色独立咖啡馆。</p>
+                    <p>无论您是需要商务洽谈的安静环境，还是休闲放松的舒适空间，都能在这里找到合适的选择。</p>
+                </div>
+                <div class="col-md-6">
+                    <div class="p-4 bg-white rounded shadow">
+                        <h4><i class="bi bi-info-circle-fill text-primary"></i> 实用信息</h4>
+                        <ul class="list-unstyled mt-3">
+                            <li class="mb-2">
+                                <i class="bi bi-geo-alt text-muted"></i> 
+                                位置：北京市大兴区荣华南路
+                            </li>
+                            <li class="mb-2">
+                                <i class="bi bi-clock text-muted"></i> 
+                                营业时间：大部分 7:00-22:00
+                            </li>
+                            <li class="mb-2">
+                                <i class="bi bi-wifi text-muted"></i> 
+                                设施：WiFi、充电插座
+                            </li>
+                            <li class="mb-2">
+                                <i class="bi bi-car-front text-muted"></i> 
+                                交通：地铁亦庄线荣昌东街站
+                            </li>
+                        </ul>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </section>
+
+    <!-- 页脚 -->
+    <footer class="bg-dark text-white py-4 mt-5">
+        <div class="container text-center">
+            <p class="mb-0">© 2024 {title}. 信息仅供参考，请以实际为准。</p>
+        </div>
+    </footer>
+
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
+    <script src="assets/js/main.js"></script>
+</body>
+</html>'''
+    
+    return html

htmlgen_mcp/improved_progress.py

@@ -0,0 +1,392 @@
+"""改进的进度日志管理 - 解决集群环境下的查询问题"""
+import json
+import time
+import os
+from pathlib import Path
+from typing import Dict, Optional, Any, List
+from datetime import datetime
+import threading
+import fcntl
+
+
+class ImprovedProgressManager:
+    """改进的进度管理器 - 支持 job_id 和 plan_id 查询"""
+    
+    def __init__(self, nas_base_path: str = "/app/mcp-servers/mcp-servers/html_agent"):
+        self.nas_base = Path(nas_base_path)
+        self.progress_base = self.nas_base / "mcp_data" / "make_web"
+        
+        # 分离不同类型的存储
+        self.jobs_dir = self.progress_base / "jobs"
+        self.plans_dir = self.progress_base / "plans"
+        self.logs_dir = self.progress_base / "logs"
+        self.mappings_dir = self.progress_base / "mappings"
+        
+        # 创建所有必要的目录
+        for dir_path in [self.jobs_dir, self.plans_dir, self.logs_dir, self.mappings_dir]:
+            dir_path.mkdir(parents=True, exist_ok=True)
+        
+        # 内存缓存，减少文件 I/O
+        self._cache = {}
+        self._cache_lock = threading.Lock()
+    
+    def register_job(self, job_id: str, plan_id: Optional[str] = None, 
+                    description: str = "", project_path: str = "") -> str:
+        """
+        注册新任务
+        
+        Args:
+            job_id: 任务 ID
+            plan_id: 关联的计划 ID（可选）
+            description: 任务描述
+            project_path: 项目路径
+            
+        Returns:
+            进度日志文件路径
+        """
+        # 生成日志文件路径
+        log_file = self.logs_dir / f"{job_id}.jsonl"
+        
+        # 创建任务信息
+        job_info = {
+            "job_id": job_id,
+            "plan_id": plan_id,
+            "description": description,
+            "project_path": project_path,
+            "log_file": str(log_file),
+            "status": "pending",
+            "created_at": datetime.now().isoformat(),
+            "node_id": os.environ.get("NODE_ID", "unknown"),
+            "updated_at": datetime.now().isoformat()
+        }
+        
+        # 保存任务信息
+        job_file = self.jobs_dir / f"{job_id}.json"
+        self._safe_write_json(job_file, job_info)
+        
+        # 如果有 plan_id，创建映射
+        if plan_id:
+            self._create_mapping(plan_id, job_id, "plan_to_job")
+            self._create_mapping(job_id, plan_id, "job_to_plan")
+        
+        # 创建日志文件映射
+        self._create_mapping(job_id, str(log_file), "job_to_log")
+        if plan_id:
+            self._create_mapping(plan_id, str(log_file), "plan_to_log")
+        
+        # 更新缓存
+        with self._cache_lock:
+            self._cache[f"job:{job_id}"] = job_info
+            if plan_id:
+                self._cache[f"plan:{plan_id}:job"] = job_id
+                self._cache[f"plan:{plan_id}:log"] = str(log_file)
+        
+        return str(log_file)
+    
+    def find_log_path(self, identifier: str) -> Optional[str]:
+        """
+        根据 job_id 或 plan_id 查找日志文件路径
+        
+        Args:
+            identifier: job_id 或 plan_id
+            
+        Returns:
+            日志文件路径，如果找不到返回 None
+        """
+        # 先检查缓存
+        with self._cache_lock:
+            # 尝试作为 job_id 查找
+            cached_job = self._cache.get(f"job:{identifier}")
+            if cached_job:
+                return cached_job.get("log_file")
+            
+            # 尝试作为 plan_id 查找
+            cached_log = self._cache.get(f"plan:{identifier}:log")
+            if cached_log:
+                return cached_log
+        
+        # 方法1: 直接查找日志文件
+        direct_log = self.logs_dir / f"{identifier}.jsonl"
+        if direct_log.exists():
+            return str(direct_log)
+        
+        # 方法2: 从任务信息中查找
+        job_file = self.jobs_dir / f"{identifier}.json"
+        if job_file.exists():
+            try:
+                job_info = self._safe_read_json(job_file)
+                if job_info and "log_file" in job_info:
+                    # 更新缓存
+                    with self._cache_lock:
+                        self._cache[f"job:{identifier}"] = job_info
+                    return job_info["log_file"]
+            except Exception:
+                pass
+        
+        # 方法3: 从映射中查找
+        mapping = self._load_mapping(identifier, "job_to_log")
+        if mapping:
+            return mapping
+        
+        mapping = self._load_mapping(identifier, "plan_to_log")
+        if mapping:
+            return mapping
+        
+        # 方法4: 扫描所有任务文件（最后的手段）
+        for job_file in self.jobs_dir.glob("*.json"):
+            try:
+                job_info = self._safe_read_json(job_file)
+                if job_info:
+                    # 检查 job_id
+                    if job_info.get("job_id") == identifier:
+                        log_file = job_info.get("log_file")
+                        if log_file:
+                            # 更新缓存
+                            with self._cache_lock:
+                                self._cache[f"job:{identifier}"] = job_info
+                            return log_file
+                    
+                    # 检查 plan_id
+                    if job_info.get("plan_id") == identifier:
+                        log_file = job_info.get("log_file")
+                        if log_file:
+                            # 更新缓存
+                            with self._cache_lock:
+                                self._cache[f"plan:{identifier}:log"] = log_file
+                            return log_file
+            except Exception:
+                continue
+        
+        return None
+    
+    def write_progress(self, job_id: str, event: Dict[str, Any]) -> bool:
+        """
+        写入进度事件
+        
+        Args:
+            job_id: 任务 ID
+            event: 进度事件
+            
+        Returns:
+            是否写入成功
+        """
+        log_path = self.find_log_path(job_id)
+        if not log_path:
+            # 如果找不到日志文件，自动注册任务
+            log_path = self.register_job(job_id)
+        
+        try:
+            # 添加时间戳
+            if "timestamp" not in event:
+                event["timestamp"] = time.time()
+            
+            # 原子写入（追加模式）
+            log_file = Path(log_path)
+            temp_file = log_file.parent / f".{log_file.name}.tmp"
+            
+            # 使用文件锁
+            with open(log_path, 'a', encoding='utf-8') as f:
+                fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                try:
+                    f.write(json.dumps(event, ensure_ascii=False))
+                    f.write('\n')
+                    f.flush()
+                    os.fsync(f.fileno())  # 强制刷新到磁盘
+                finally:
+                    fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+            
+            # 更新任务状态
+            self._update_job_status(job_id, event)
+            
+            return True
+            
+        except Exception as e:
+            print(f"写入进度失败: {e}")
+            return False
+    
+    def read_progress(self, identifier: str, limit: int = 100, 
+                     since_timestamp: Optional[float] = None) -> List[Dict[str, Any]]:
+        """
+        读取进度事件
+        
+        Args:
+            identifier: job_id 或 plan_id
+            limit: 返回事件数量限制
+            since_timestamp: 从此时间戳之后的事件
+            
+        Returns:
+            进度事件列表
+        """
+        log_path = self.find_log_path(identifier)
+        if not log_path or not Path(log_path).exists():
+            return []
+        
+        events = []
+        try:
+            with open(log_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    if line.strip():
+                        try:
+                            event = json.loads(line)
+                            # 过滤时间戳
+                            if since_timestamp and event.get("timestamp", 0) <= since_timestamp:
+                                continue
+                            events.append(event)
+                            # 限制数量
+                            if len(events) >= limit:
+                                break
+                        except json.JSONDecodeError:
+                            continue
+        except Exception as e:
+            print(f"读取进度失败: {e}")
+        
+        return events
+    
+    def get_job_status(self, job_id: str) -> Optional[Dict[str, Any]]:
+        """
+        获取任务状态
+        
+        Args:
+            job_id: 任务 ID
+            
+        Returns:
+            任务状态信息
+        """
+        # 先检查缓存
+        with self._cache_lock:
+            cached = self._cache.get(f"job:{job_id}")
+            if cached and time.time() - cached.get("_cache_time", 0) < 5:  # 5秒缓存
+                return cached
+        
+        # 从文件读取
+        job_file = self.jobs_dir / f"{job_id}.json"
+        if job_file.exists():
+            try:
+                job_info = self._safe_read_json(job_file)
+                if job_info:
+                    # 更新缓存
+                    job_info["_cache_time"] = time.time()
+                    with self._cache_lock:
+                        self._cache[f"job:{job_id}"] = job_info
+                    return job_info
+            except Exception:
+                pass
+        
+        return None
+    
+    def _create_mapping(self, key: str, value: str, mapping_type: str):
+        """创建映射关系"""
+        mapping_file = self.mappings_dir / f"{mapping_type}.json"
+        
+        # 读取现有映射
+        mappings = {}
+        if mapping_file.exists():
+            try:
+                mappings = self._safe_read_json(mapping_file) or {}
+            except Exception:
+                mappings = {}
+        
+        # 更新映射
+        mappings[key] = value
+        
+        # 保存映射
+        self._safe_write_json(mapping_file, mappings)
+    
+    def _load_mapping(self, key: str, mapping_type: str) -> Optional[str]:
+        """加载映射关系"""
+        mapping_file = self.mappings_dir / f"{mapping_type}.json"
+        
+        if mapping_file.exists():
+            try:
+                mappings = self._safe_read_json(mapping_file)
+                if mappings:
+                    return mappings.get(key)
+            except Exception:
+                pass
+        
+        return None
+    
+    def _update_job_status(self, job_id: str, event: Dict[str, Any]):
+        """更新任务状态"""
+        job_file = self.jobs_dir / f"{job_id}.json"
+        
+        # 读取现有信息
+        job_info = {}
+        if job_file.exists():
+            job_info = self._safe_read_json(job_file) or {}
+        
+        # 更新状态
+        if "status" in event:
+            job_info["status"] = event["status"]
+        if "progress" in event:
+            job_info["progress"] = event["progress"]
+        
+        job_info["updated_at"] = datetime.now().isoformat()
+        job_info["last_event"] = event
+        
+        # 保存更新
+        self._safe_write_json(job_file, job_info)
+        
+        # 更新缓存
+        job_info["_cache_time"] = time.time()
+        with self._cache_lock:
+            self._cache[f"job:{job_id}"] = job_info
+    
+    def _safe_write_json(self, file_path: Path, data: Dict):
+        """安全写入 JSON 文件（原子操作）"""
+        temp_file = file_path.parent / f".{file_path.name}.tmp"
+        
+        try:
+            # 先写入临时文件
+            with open(temp_file, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+                f.flush()
+                os.fsync(f.fileno())
+            
+            # 原子重命名
+            temp_file.replace(file_path)
+            
+        except Exception as e:
+            # 清理临时文件
+            if temp_file.exists():
+                temp_file.unlink()
+            raise e
+    
+    def _safe_read_json(self, file_path: Path) -> Optional[Dict]:
+        """安全读取 JSON 文件"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception:
+            return None
+    
+    def cleanup_old_logs(self, days_to_keep: int = 7) -> int:
+        """清理旧的日志文件"""
+        cleaned = 0
+        cutoff_time = time.time() - (days_to_keep * 24 * 3600)
+        
+        for log_file in self.logs_dir.glob("*.jsonl"):
+            try:
+                if log_file.stat().st_mtime < cutoff_time:
+                    log_file.unlink()
+                    cleaned += 1
+            except Exception:
+                continue
+        
+        return cleaned
+
+
+# 全局实例
+_progress_manager: Optional[ImprovedProgressManager] = None
+
+
+def get_progress_manager() -> ImprovedProgressManager:
+    """获取进度管理器实例（单例）"""
+    global _progress_manager
+    if _progress_manager is None:
+        nas_path = os.environ.get(
+            "NAS_STORAGE_PATH",
+            "/app/mcp-servers/mcp-servers/html_agent"
+        )
+        _progress_manager = ImprovedProgressManager(nas_path)
+    return _progress_manager