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

htmlgen_mcp/nas_log_manager.py

@@ -0,0 +1,308 @@
+"""简化的 NAS 日志管理器 - 直接在 NAS 上读写日志"""
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import time
+from datetime import datetime
+
+
+class NASLogManager:
+    """NAS 日志管理器 - 所有操作直接在 NAS 上进行"""
+    
+    def __init__(self, nas_base_path: str = "/app/mcp-servers/mcp-servers/html_agent"):
+        self.nas_base = Path(nas_base_path)
+        
+        # 日志存储目录
+        self.logs_dir = self.nas_base / "mcp_data" / "make_web" / "progress_logs"
+        self.jobs_dir = self.nas_base / "mcp_data" / "make_web" / "jobs"
+        self.index_dir = self.nas_base / "mcp_data" / "make_web" / "job_index"
+        
+        # 创建目录
+        for dir_path in [self.logs_dir, self.jobs_dir, self.index_dir]:
+            dir_path.mkdir(parents=True, exist_ok=True)
+    
+    def create_job_log(self, job_id: str, plan_id: Optional[str] = None) -> str:
+        """
+        创建任务日志文件
+        
+        Args:
+            job_id: 任务 ID
+            plan_id: 计划 ID（可选）
+            
+        Returns:
+            日志文件路径
+        """
+        # 日志文件路径
+        log_file = self.logs_dir / f"{job_id}.jsonl"
+        
+        # 创建索引文件（用于快速查找）
+        index_data = {
+            "job_id": job_id,
+            "plan_id": plan_id,
+            "log_file": str(log_file),
+            "created_at": datetime.now().isoformat(),
+            "node_id": os.environ.get("NODE_ID", "unknown")
+        }
+        
+        # 保存 job_id 索引
+        job_index_file = self.index_dir / f"{job_id}.json"
+        with open(job_index_file, 'w', encoding='utf-8') as f:
+            json.dump(index_data, f, ensure_ascii=False, indent=2)
+        
+        # 如果有 plan_id，也创建索引
+        if plan_id:
+            plan_index_file = self.index_dir / f"{plan_id}.json"
+            with open(plan_index_file, 'w', encoding='utf-8') as f:
+                json.dump(index_data, f, ensure_ascii=False, indent=2)
+        
+        # 初始化日志文件
+        if not log_file.exists():
+            with open(log_file, 'w', encoding='utf-8') as f:
+                init_event = {
+                    "timestamp": time.time(),
+                    "event": "job_created",
+                    "job_id": job_id,
+                    "plan_id": plan_id,
+                    "created_at": datetime.now().isoformat()
+                }
+                f.write(json.dumps(init_event, ensure_ascii=False) + '\n')
+        
+        return str(log_file)
+    
+    def find_log_file(self, identifier: str) -> Optional[str]:
+        """
+        查找日志文件路径（支持 job_id 和 plan_id）
+        
+        Args:
+            identifier: job_id 或 plan_id
+            
+        Returns:
+            日志文件路径，如果找不到返回 None
+        """
+        # 方法1: 检查索引文件
+        index_file = self.index_dir / f"{identifier}.json"
+        if index_file.exists():
+            try:
+                with open(index_file, 'r', encoding='utf-8') as f:
+                    index_data = json.load(f)
+                    log_file = index_data.get("log_file")
+                    if log_file and Path(log_file).exists():
+                        return log_file
+            except Exception:
+                pass
+        
+        # 方法2: 直接检查是否是 job_id
+        direct_log = self.logs_dir / f"{identifier}.jsonl"
+        if direct_log.exists():
+            return str(direct_log)
+        
+        # 方法3: 扫描所有索引文件查找 plan_id
+        for index_file in self.index_dir.glob("*.json"):
+            try:
+                with open(index_file, 'r', encoding='utf-8') as f:
+                    index_data = json.load(f)
+                    if (index_data.get("job_id") == identifier or 
+                        index_data.get("plan_id") == identifier):
+                        log_file = index_data.get("log_file")
+                        if log_file and Path(log_file).exists():
+                            return log_file
+            except Exception:
+                continue
+        
+        return None
+    
+    def write_progress(self, identifier: str, event: Dict[str, Any]) -> bool:
+        """
+        写入进度事件
+        
+        Args:
+            identifier: job_id 或 plan_id
+            event: 进度事件
+            
+        Returns:
+            是否写入成功
+        """
+        log_file_path = self.find_log_file(identifier)
+        
+        # 如果找不到日志文件，尝试创建
+        if not log_file_path:
+            # 假设 identifier 是 job_id
+            log_file_path = self.create_job_log(identifier)
+        
+        try:
+            # 添加时间戳
+            if "timestamp" not in event:
+                event["timestamp"] = time.time()
+            
+            # 追加写入日志
+            with open(log_file_path, 'a', encoding='utf-8') as f:
+                f.write(json.dumps(event, ensure_ascii=False) + '\n')
+                f.flush()  # 立即刷新到 NAS
+            
+            return True
+            
+        except Exception as e:
+            print(f"写入进度失败 {identifier}: {e}")
+            return False
+    
+    def read_progress(self, identifier: str, limit: int = 100) -> List[Dict[str, Any]]:
+        """
+        读取进度事件
+        
+        Args:
+            identifier: job_id 或 plan_id
+            limit: 返回事件数量限制
+            
+        Returns:
+            进度事件列表
+        """
+        log_file_path = self.find_log_file(identifier)
+        if not log_file_path:
+            return []
+        
+        events = []
+        try:
+            with open(log_file_path, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+                
+                # 从最新的开始读取
+                for line in reversed(lines[-limit:]):
+                    if line.strip():
+                        try:
+                            event = json.loads(line)
+                            events.insert(0, event)  # 保持时间顺序
+                        except json.JSONDecodeError:
+                            continue
+                            
+        except Exception as e:
+            print(f"读取进度失败 {identifier}: {e}")
+        
+        return events
+    
+    def get_all_jobs(self) -> List[Dict[str, Any]]:
+        """
+        获取所有任务列表
+        
+        Returns:
+            任务列表
+        """
+        jobs = []
+        
+        # 扫描所有索引文件
+        for index_file in self.index_dir.glob("*.json"):
+            try:
+                with open(index_file, 'r', encoding='utf-8') as f:
+                    index_data = json.load(f)
+                    # 只添加 job_id 的记录，避免重复
+                    if index_data.get("job_id") == index_file.stem:
+                        jobs.append(index_data)
+            except Exception:
+                continue
+        
+        # 按创建时间排序
+        jobs.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+        
+        return jobs
+    
+    def job_exists(self, identifier: str) -> bool:
+        """
+        检查任务是否存在
+        
+        Args:
+            identifier: job_id 或 plan_id
+            
+        Returns:
+            任务是否存在
+        """
+        return self.find_log_file(identifier) is not None
+    
+    def get_job_summary(self, identifier: str) -> Optional[Dict[str, Any]]:
+        """
+        获取任务摘要信息
+        
+        Args:
+            identifier: job_id 或 plan_id
+            
+        Returns:
+            任务摘要
+        """
+        log_file_path = self.find_log_file(identifier)
+        if not log_file_path:
+            return None
+        
+        try:
+            # 读取最近的几个事件
+            events = self.read_progress(identifier, limit=10)
+            if not events:
+                return None
+            
+            # 获取最新事件
+            latest_event = events[-1] if events else {}
+            first_event = events[0] if events else {}
+            
+            summary = {
+                "identifier": identifier,
+                "log_file": log_file_path,
+                "total_events": len(events),
+                "first_event_time": first_event.get("timestamp"),
+                "latest_event_time": latest_event.get("timestamp"),
+                "latest_status": latest_event.get("status", "unknown"),
+                "latest_message": latest_event.get("message", ""),
+            }
+            
+            # 尝试获取索引信息
+            index_file = self.index_dir / f"{identifier}.json"
+            if index_file.exists():
+                try:
+                    with open(index_file, 'r', encoding='utf-8') as f:
+                        index_data = json.load(f)
+                        summary.update({
+                            "job_id": index_data.get("job_id"),
+                            "plan_id": index_data.get("plan_id"),
+                            "created_at": index_data.get("created_at"),
+                            "node_id": index_data.get("node_id")
+                        })
+                except Exception:
+                    pass
+            
+            return summary
+            
+        except Exception as e:
+            print(f"获取任务摘要失败 {identifier}: {e}")
+            return None
+
+
+# 全局实例
+_nas_log_manager: Optional[NASLogManager] = None
+
+
+def get_nas_log_manager() -> NASLogManager:
+    """获取 NAS 日志管理器实例（单例）"""
+    global _nas_log_manager
+    if _nas_log_manager is None:
+        nas_path = os.environ.get(
+            "NAS_STORAGE_PATH",
+            "/app/mcp-servers/mcp-servers/html_agent"
+        )
+        _nas_log_manager = NASLogManager(nas_path)
+    return _nas_log_manager
+
+
+# 便捷函数
+def log_progress(job_id: str, **kwargs):
+    """记录进度的便捷函数"""
+    manager = get_nas_log_manager()
+    return manager.write_progress(job_id, kwargs)
+
+
+def query_progress(identifier: str, limit: int = 20):
+    """查询进度的便捷函数"""
+    manager = get_nas_log_manager()
+    return manager.read_progress(identifier, limit)
+
+
+def ensure_job_log(job_id: str, plan_id: Optional[str] = None):
+    """确保任务日志存在的便捷函数"""
+    manager = get_nas_log_manager()
+    return manager.create_job_log(job_id, plan_id)

htmlgen_mcp/prompt_enhancer.py

@@ -0,0 +1,240 @@
+"""提示词增强模块 - 确保AI使用真实数据而非生成示例"""
+
+
+class PromptEnhancer:
+    """提示词增强器，用于改进AI对真实数据的处理"""
+    
+    @staticmethod
+    def enhance_for_real_data(base_prompt: str, context_data: str = None) -> str:
+        """
+        增强提示词，确保AI使用真实数据
+        
+        Args:
+            base_prompt: 基础提示词
+            context_data: 上下文数据内容
+            
+        Returns:
+            增强后的提示词
+        """
+        if not context_data:
+            return base_prompt
+            
+        # 分析数据类型
+        data_type = PromptEnhancer._analyze_data_type(context_data)
+        
+        # 根据数据类型生成特定的指令
+        specific_instructions = PromptEnhancer._get_specific_instructions(data_type, context_data)
+        
+        enhanced = f"""
+{base_prompt}
+
+【🔴 极其重要的数据使用规则 🔴】
+=====================================
+以下是必须严格遵守的数据使用规则：
+
+1. 【数据来源】下面提供的是真实的业务数据，不是示例或模板
+2. 【使用要求】必须100%使用这些数据，不得修改、省略或虚构
+3. 【禁止行为】严禁生成以下虚构内容：
+   - ❌ 虚构的客户评价（如"设计质感与转化率提升明显"）
+   - ❌ 虚构的定价方案（如"¥9,999起步套餐"）
+   - ❌ 虚构的服务内容（如"品牌升级与重构"）
+   - ❌ 占位符内容（如"Lorem ipsum"或"示例文本"）
+   
+4. 【正确做法】：
+   - ✅ 完整展示所有提供的数据项
+   - ✅ 保持数据的原始格式和内容
+   - ✅ 使用合适的布局展示（卡片、列表、表格等）
+   - ✅ 可以添加导航、样式，但内容必须是提供的真实数据
+
+【必须使用的真实数据】
+=====================================
+{context_data}
+=====================================
+
+{specific_instructions}
+
+【工具调用要求】
+=====================================
+在调用以下工具时，必须包含真实数据：
+- create_html_file: content参数必须包含上述真实数据
+- add_content_section: 必须使用真实数据填充内容
+- create_text_content: 文本内容必须来自上述数据
+- add_hero_section: 标题和描述要反映真实业务
+- create_card_grid: 卡片内容必须是真实数据项
+
+【验证要求】
+=====================================
+生成的每个HTML文件都必须包含：
+1. 完整的数据列表（不得遗漏任何一项）
+2. 准确的名称和地址信息
+3. 正确的数据展示格式
+
+记住：这是一个数据展示任务，不是创意写作任务！
+"""
+        return enhanced
+    
+    @staticmethod
+    def _analyze_data_type(context_data: str) -> str:
+        """
+        分析数据类型
+        
+        Args:
+            context_data: 上下文数据
+            
+        Returns:
+            数据类型标识
+        """
+        lower_data = context_data.lower()
+        
+        # 检测不同类型的数据
+        if "咖啡" in context_data or "coffee" in lower_data or "店" in context_data:
+            if "地址" in context_data or "address" in lower_data:
+                return "store_list"
+                
+        if "产品" in context_data or "product" in lower_data:
+            return "product_list"
+            
+        if "菜单" in context_data or "menu" in lower_data:
+            return "menu_list"
+            
+        if "价格" in context_data or "price" in lower_data:
+            return "pricing_list"
+            
+        if "联系" in context_data or "contact" in lower_data:
+            return "contact_info"
+            
+        return "general_list"
+    
+    @staticmethod
+    def _get_specific_instructions(data_type: str, context_data: str) -> str:
+        """
+        根据数据类型生成特定指令
+        
+        Args:
+            data_type: 数据类型
+            context_data: 上下文数据
+            
+        Returns:
+            特定的指令
+        """
+        # 计算数据项数量
+        item_count = context_data.count('\n1.') + context_data.count('\n2.') + \
+                     context_data.count('\n3.') + context_data.count('\n-')
+        
+        if data_type == "store_list":
+            return f"""
+【针对店铺列表的特定要求】
+- 必须展示所有{item_count}个店铺
+- 每个店铺必须包含：名称、地址
+- 使用卡片布局，每行2-3个
+- 可以添加地图链接按钮
+- 可以按区域或品牌分组展示
+"""
+        
+        elif data_type == "product_list":
+            return f"""
+【针对产品列表的特定要求】
+- 必须展示所有产品信息
+- 保持原始的产品名称和描述
+- 使用产品卡片或展示网格
+- 可以添加产品图片占位符
+"""
+        
+        elif data_type == "menu_list":
+            return f"""
+【针对菜单的特定要求】
+- 必须展示完整菜单
+- 保持原始的菜品名称和价格
+- 可以按类别分组
+- 使用清晰的表格或列表格式
+"""
+        
+        else:
+            return f"""
+【通用数据展示要求】
+- 必须展示所有数据项（共约{item_count}项）
+- 保持数据的原始格式
+- 使用适合的布局展示
+- 不得添加虚构内容
+"""
+    
+    @staticmethod
+    def validate_content_usage(generated_content: str, original_data: str) -> dict:
+        """
+        验证生成的内容是否正确使用了原始数据
+        
+        Args:
+            generated_content: 生成的内容
+            original_data: 原始数据
+            
+        Returns:
+            验证结果
+        """
+        # 提取原始数据中的关键项
+        key_items = []
+        lines = original_data.split('\n')
+        for line in lines:
+            line = line.strip()
+            # 提取店名或关键信息
+            if '. ' in line and line[0].isdigit():
+                item = line.split('. ', 1)[1] if '. ' in line else line
+                if '(' in item:
+                    item = item.split('(')[0].strip()
+                key_items.append(item)
+            elif '- 地址：' in line:
+                address = line.replace('- 地址：', '').strip()
+                key_items.append(address)
+        
+        # 检查每个关键项是否在生成的内容中
+        missing_items = []
+        found_items = []
+        
+        for item in key_items:
+            if item in generated_content:
+                found_items.append(item)
+            else:
+                missing_items.append(item)
+        
+        # 检测虚构内容的特征
+        fake_content_patterns = [
+            "转化率提升",
+            "品牌形象",
+            "¥9,999",
+            "¥29,999",
+            "¥59,999",
+            "起步套餐",
+            "专业套餐",
+            "旗舰套餐",
+            "Alex Chen",
+            "Liang Wu",
+            "Yvonne Zhao",
+            "设计质感",
+            "交付质量",
+            "Lorem ipsum",
+            "示例文本"
+        ]
+        
+        detected_fake = [pattern for pattern in fake_content_patterns 
+                        if pattern in generated_content]
+        
+        return {
+            "valid": len(missing_items) == 0 and len(detected_fake) == 0,
+            "found_items": found_items,
+            "missing_items": missing_items,
+            "detected_fake_content": detected_fake,
+            "coverage_rate": len(found_items) / len(key_items) if key_items else 0,
+            "has_fake_content": len(detected_fake) > 0
+        }
+
+
+# 导出便捷函数
+def enhance_prompt_for_real_data(prompt: str, context: str = None) -> str:
+    """增强提示词以使用真实数据"""
+    enhancer = PromptEnhancer()
+    return enhancer.enhance_for_real_data(prompt, context)
+
+
+def validate_data_usage(content: str, original: str) -> dict:
+    """验证数据使用情况"""
+    enhancer = PromptEnhancer()
+    return enhancer.validate_content_usage(content, original)

htmlgen_mcp/web_agent_server.py

@@ -32,6 +32,8 @@ from pathlib import Path
 
 from htmlgen_mcp.agents.smart_web_agent import SmartWebAgent
 from htmlgen_mcp.nas_storage import get_nas_storage
+from htmlgen_mcp.nas_log_manager import get_nas_log_manager, ensure_job_log, log_progress, query_progress
+from htmlgen_mcp.prompt_enhancer import enhance_prompt_for_real_data
 from datetime import datetime
 
 # 使用 NAS 作为默认存储路径
@@ -87,6 +89,8 @@ def _persist_job_state(job_id: str) -> None:
         return
     job_copy = {k: v for k, v in job.items() if k not in {"agent"}}
     job_copy["updated_at"] = time.time()
+    
+    # 同时保存到本地和 NAS
     path = _job_state_path(job_id)
     try:
         path.write_text(
@@ -94,6 +98,15 @@ def _persist_job_state(job_id: str) -> None:
         )
     except Exception:
         pass
+    
+    # 保存到 NAS 日志
+    try:
+        log_manager = get_nas_log_manager()
+        plan_id = job.get("plan_id")
+        log_manager.create_job_log(job_id, plan_id)
+        log_progress(job_id, status="registered", job_info=job_copy)
+    except Exception:
+        pass
 
 
 def _load_job_states() -> None:
@@ -257,12 +270,15 @@ def _execute_plan(
     plan: Dict[str, Any],
     *,
     progress_log_path: Optional[str] = None,
+    job_id: Optional[str] = None,
 ) -> Dict[str, Any]:
     progress_events: list[Dict[str, Any]] = []
 
     def _collect(event: Dict[str, Any]) -> None:
         if isinstance(event, dict):
             progress_events.append(event)
+            
+            # 写入本地日志
             if progress_log_path:
                 try:
                     log_record = dict(event)
@@ -272,6 +288,13 @@ def _execute_plan(
                         log_file.write("\n")
                 except Exception:
                     pass
+            
+            # 同时写入 NAS 日志
+            if job_id:
+                try:
+                    log_progress(job_id, **event)
+                except Exception:
+                    pass
 
     results = agent._execute_plan_with_recovery(
         plan,
@@ -754,42 +777,45 @@ async def create_simple_site(
             force_single_page=True,
         )
 
-        # 构建针对简单网站的提示，包含上下文和图片要求
-        context_section = ""
+        # 如果有上下文内容，将其整合到描述中
+        enhanced_description = description
         if context_data:
-            context_section = f"""
+            enhanced_description = f"""{description}
 
-**上下文内容**:
+【必须使用的具体数据内容】：
 {context_data}
 
-**重要说明**: 请根据上述上下文内容来定制网站的具体内容，确保生成的网页与提供的信息高度匹配。"""
+【重要提示】：上述数据是真实的业务数据，必须完整准确地展示在网页中，不要生成虚构的示例内容。"""
 
-        simple_prompt = f"""请为以下需求设计一个简单但美观的网站：
+        # 构建改进的提示词，强调使用真实数据
+        simple_prompt = f"""请为以下需求创建一个网站，并严格使用提供的真实数据：
 
-**网站需求**: {description}
-**网站标题**: {site_title}{context_section}
+**网站标题**: {site_title}
+**具体需求和数据**: 
+{enhanced_description}
 
-**设计要求**:
-1. 保持简洁但要有视觉吸引力
-2. 使用轻量级CSS（不超过300行）
-3. 包含基础但实用的功能
-4. 响应式设计，适配移动端
-5. 良好的配色和排版
-6. 智能图片集成，根据内容类型匹配合适主题
-7. 如果有上下文内容，请充分利用这些信息来丰富网页内容
+**执行要求**：
+1. 【数据要求】如果提供了具体数据（如店铺列表、产品信息等），必须100%使用这些真实数据，不要创建虚构内容
+2. 【内容展示】将所有提供的数据项完整展示，使用合适的布局（如卡片、列表、表格等）
+3. 【样式设计】保持简洁美观，使用响应式设计
+4. 【代码限制】CSS不超过300行，避免复杂特效
+5. 【功能实现】包含基础交互功能（导航、滚动等）
 
-请生成一个包含3-6个步骤的简化执行计划，每个步骤要简洁明确。
-重点关注：页面结构、样式设计、图片集成、必要功能。避免复杂特效。
+**特别强调**：
+- 当创建HTML内容时，必须使用上面提供的真实数据
+- 不要生成"示例客户评价"、"虚拟定价方案"等占位内容
+- 如果是咖啡馆列表，就展示真实的咖啡馆名称和地址
+- 如果是产品信息，就展示真实的产品数据
+- 每个create_html_file或add_content_section工具调用时，都要包含真实数据
 
-输出格式要求：
-- 每个步骤都要具体可执行
-- 优先使用简单模板函数而非复杂模板
-- 注重实用性和美观性的平衡
-- 充分利用提供的上下文信息来生成个性化内容
+请生成3-6个步骤的执行计划，确保每个步骤都能正确使用提供的数据。
 """
 
         # 生成简化计划（仅规划，不执行）
-        plan = agent._get_execution_plan(simple_prompt)
+        # 传递强化后的提示词，确保AI使用真实数据
+        # 使用提示词增强器进一步强化
+        final_prompt = enhance_prompt_for_real_data(simple_prompt, context_data)
+        plan = agent._get_execution_plan(final_prompt)
 
         # 在计划中标记为简单网站类型和相关信息
         plan["site_type"] = "simple"
@@ -804,9 +830,8 @@ async def create_simple_site(
         plan_id = str(uuid.uuid4())
 
         # 构建完整的源描述（包含上下文）
-        source_description = description
-        if context_data:
-            source_description = f"{description}\n\n【附加内容】\n{context_data}"
+        # 使用enhanced_description以确保数据被传递
+        source_description = enhanced_description
 
         # 在计划中添加源描述字段
         plan["__source_description"] = source_description

{htmlgen_mcp-0.3.4.dist-info → htmlgen_mcp-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgen-mcp
-Version: 0.3.4
+Version: 0.3.6
 Summary: AI-powered HTML website generator with auto-upload functionality via Model Context Protocol
 Author-email: HTML Generator Team <contact@htmlgen-mcp.com>
 License: MIT