travel-agent-cli 0.2.0 → 0.2.1

package/python/agents/report_agent.py

@@ -0,0 +1,172 @@
+"""报告 Agent - 负责生成旅行推荐报告"""
+from typing import Dict, Any, List, Optional
+import json
+from datetime import datetime
+from agents.base import BaseAgent
+
+
+class ReportAgent(BaseAgent):
+    """报告 Agent
+
+    职责：
+    - 撰写旅行推荐报告
+    - 格式化输出
+    - 生成 Markdown 内容
+    """
+
+    name = "report_agent"
+    role = "旅行专栏作家"
+    goal = "撰写生动有趣、专业实用的旅行推荐报告"
+
+    def __init__(
+        self,
+        provider: Optional[str] = None,
+        model: Optional[str] = None,
+        use_tools: bool = False,
+    ):
+        super().__init__(provider, model, use_tools)
+
+    async def execute_local(self, task: str, context: Dict[str, Any]) -> str:
+        """本地生成报告"""
+        destinations = context.get("destinations", [])
+        routes = context.get("routes", [])
+
+        # 生成简化的 Markdown 报告
+        lines = [
+            "# 旅行目的地推荐报告",
+            "",
+            f"> 生成时间：{datetime.now().strftime('%Y-%m-%d %H:%M')}",
+            "",
+            f"本期推荐 {len(destinations)} 个热门旅行目的地。",
+            "",
+            "---",
+            "",
+            "## 🏆 TOP 目的地推荐",
+            ""
+        ]
+
+        for dest in destinations[:10]:
+            lines.extend([
+                f"### {dest.get('rank', '?')}. {dest.get('name', '未知')}",
+                "",
+                f"**得分：** {dest.get('score', 0)}/10",
+                f"**理由：** {dest.get('reason', '')}",
+                "",
+                f"- 💰 **费用：** {dest.get('estimated_cost', 'N/A')}",
+                f"- 📅 **天数：** {dest.get('suggested_days', 0)}天",
+                f"- 🕐 **最佳时间：** {dest.get('best_time', 'N/A')}",
+                ""
+            ])
+
+        return "\n".join(lines)
+
+    async def write_report(
+        self,
+        recommendations: List[Dict[str, Any]],
+        routes: List[Dict[str, Any]],
+        summary: str = None
+    ) -> str:
+        """撰写完整报告
+
+        Args:
+            recommendations: 推荐目的地列表
+            routes: 路线规划列表
+            summary: 可选的总结文字
+
+        Returns:
+            Markdown 格式报告
+        """
+        task = f"""你是一位资深旅行专栏作家。请根据以下数据撰写一篇完整的旅行推荐报告。
+
+## 推荐目的地
+{json.dumps(recommendations, ensure_ascii=False, indent=2, default=str)}
+
+## 路线规划
+{json.dumps(routes, ensure_ascii=False, indent=2, default=str)}
+
+## 报告要求
+
+1. **标题**：要有吸引力，体现"热点推荐"主题
+2. **导语**：100-200 字引人入胜的开场
+3. **TOP10 目的地**：每个目的地包含：
+   - 排名和名称
+   - 综合得分
+   - 推荐理由（生动详细，100-200 字）
+   - 实用信息（费用、天数、最佳时间）
+   - 亮点特色
+4. **详细路线**：为 TOP3-5 目的地提供详细行程
+5. **出行提示**：实用的旅行建议
+6. **语言风格**：轻松有趣，适合社交媒体传播
+
+## 输出格式
+
+请输出完整的 Markdown 格式报告，包含：
+- 吸引人的标题（# 一级标题）
+- 导语（引用块）
+- 各目的地介绍（## 二级标题 + ### 三级标题）
+- 路线详情（使用表格）
+- 出行提示列表
+
+{f"参考总结：{summary}" if summary else ""}
+"""
+
+        return await self.execute(task, {
+            "recommendations": recommendations,
+            "routes": routes,
+            "summary": summary
+        })
+
+    async def write_summary(
+        self,
+        destinations: List[Dict[str, Any]]
+    ) -> str:
+        """生成报告摘要
+
+        Args:
+            destinations: 目的地列表
+
+        Returns:
+            摘要文字
+        """
+        task = f"""请为以下旅行目的地推荐生成一段简短的摘要（100-200 字）。
+
+目的地列表：
+{json.dumps([{"name": d.get("name"), "score": d.get("score"), "reason": d.get("reason")} for d in destinations[:10]], ensure_ascii=False, indent=2)}
+
+摘要要求：
+- 概括本期推荐特点
+- 提及 TOP3 目的地
+- 语言生动有吸引力
+- 适合放在报告开头
+
+直接输出摘要内容，不需要标题。"""
+
+        return await self.execute(task, {"destinations": destinations})
+
+    async def format_report(
+        self,
+        content: str,
+        output_format: str = "markdown"
+    ) -> str:
+        """格式化报告
+
+        Args:
+            content: 报告内容
+            output_format: 输出格式（markdown/html/text）
+
+        Returns:
+            格式化后的内容
+        """
+        if output_format == "markdown":
+            return content
+        elif output_format == "html":
+            # 简单的 Markdown 转 HTML
+            task = f"""请将以下 Markdown 内容转换为 HTML：
+
+{content}
+
+直接输出 HTML 代码，不需要解释。"""
+            return await self.execute(task, {"content": content})
+        else:
+            # 纯文本
+            return content

package/python/analyzers/__init__.py

@@ -0,0 +1,10 @@
+"""分析模块"""
+from analyzers.hot_score import HotScoreCalculator
+from analyzers.ranker import DestinationRanker
+from analyzers.route_planner import RoutePlanner
+
+__all__ = [
+    "HotScoreCalculator",
+    "DestinationRanker",
+    "RoutePlanner",
+]

package/python/analyzers/hot_score.py

@@ -0,0 +1,123 @@
+"""热度评分计算模块"""
+from typing import List, Dict
+from datetime import datetime, timedelta
+from config.models import SocialPost, WenlvInfo
+
+
+class HotScoreCalculator:
+    """热度评分计算器"""
+
+    def calculate_post_score(self, post: SocialPost, days_decay: float = 0.1) -> float:
+        """计算单条帖子的热度得分
+
+        Args:
+            post: 社交媒体帖子
+            days_decay: 每日衰减系数
+
+        评分维度：
+        - 基础互动分：点赞、评论、转发
+        - 时间衰减：越新的内容权重越高
+        - 平台权重：不同平台影响力不同
+        """
+        # 基础互动分
+        base_score = post.engagement_score
+
+        # 时间衰减
+        if post.published_at:
+            days_old = (datetime.now() - post.published_at).days
+            time_factor = 0.9 ** days_old  # 每天衰减 10%
+        else:
+            time_factor = 0.5
+
+        # 平台权重
+        platform_weights = {
+            "xiaohongshu": 1.2,  # 小红书权重较高
+            "weibo": 1.0,
+            "wenlv": 0.8,
+        }
+        platform_weight = platform_weights.get(post.source.value, 1.0)
+
+        return base_score * time_factor * platform_weight
+
+    def calculate_destination_score(
+        self,
+        destination: str,
+        posts: List[SocialPost],
+        wenlv_infos: List[WenlvInfo],
+        flight_price: float = 0,
+        hotel_price: float = 0,
+    ) -> Dict:
+        """计算目的地综合得分
+
+        评分维度：
+        - 社交媒体热度（40%）
+        - 政策支持（20%）
+        - 性价比（20%）
+        - 季节性（20%）
+        """
+        # 1. 社交媒体热度
+        related_posts = [
+            p for p in posts
+            if destination in p.title or destination in p.content or
+               any(destination in tag for tag in p.tags)
+        ]
+
+        social_score = sum(self.calculate_post_score(p) for p in related_posts)
+        # 归一化到 0-10
+        social_score = min(10, social_score / 1000) if social_score > 0 else 5
+
+        # 2. 政策支持
+        related_wenlv = [w for w in wenlv_infos if destination in w.title or destination in w.content]
+        policy_score = len(related_wenlv) * 2  # 每条政策加 2 分
+        policy_score = min(10, policy_score)
+
+        # 3. 性价比（价格越低分越高）
+        avg_price = (flight_price + hotel_price) / 2 if (flight_price and hotel_price) else 500
+        if avg_price > 0:
+            price_score = max(1, 10 - (avg_price / 200))  # 每 200 元扣 1 分
+        else:
+            price_score = 5
+
+        # 4. 季节性（当前月份适合度）
+        current_month = datetime.now().month
+        seasonal_score = self._get_seasonal_score(destination, current_month)
+
+        # 综合得分
+        total_score = (
+            social_score * 0.4 +
+            policy_score * 0.2 +
+            price_score * 0.2 +
+            seasonal_score * 0.2
+        )
+
+        return {
+            "destination": destination,
+            "social_score": round(social_score, 2),
+            "policy_score": round(policy_score, 2),
+            "price_score": round(price_score, 2),
+            "seasonal_score": round(seasonal_score, 2),
+            "total_score": round(total_score, 2),
+            "post_count": len(related_posts),
+            "policy_count": len(related_wenlv),
+        }
+
+    def _get_seasonal_score(self, destination: str, month: int) -> float:
+        """获取目的地季节性评分"""
+        # 简化的季节性匹配
+        seasonal_destinations = {
+            # 春季 (3-5 月)
+            (3, 4, 5): ["婺源", "林芝", "罗平", "兴化", "杭州", "苏州"],
+            # 夏季 (6-8 月)
+            (6, 7, 8): ["青海湖", "呼伦贝尔", "丽江", "大理", "香格里拉", "西北大环线"],
+            # 秋季 (9-11 月)
+            (9, 10, 11): ["九寨沟", "喀纳斯", "稻城亚丁", "长白山", "腾冲"],
+            # 冬季 (12-2 月)
+            (12, 1, 2): ["三亚", "西双版纳", "哈尔滨", "雪乡", "北海"],
+        }
+
+        for months, dests in seasonal_destinations.items():
+            if month in months:
+                if any(d in destination for d in dests):
+                    return 10.0
+
+        return 6.0  # 默认分数

package/python/analyzers/ranker.py

@@ -0,0 +1,225 @@
+"""目的地排序器 - 使用 Claude API 进行分析排序"""
+import asyncio
+import json
+from typing import List, Optional, Dict
+from datetime import datetime
+
+from anthropic import Anthropic
+from config.models import (
+    SocialPost,
+    WenlvInfo,
+    FlightInfo,
+    HotelInfo,
+    DestinationRecommendation,
+)
+from config.settings import get_settings
+from config.prompts import DESTINATION_ANALYSIS_PROMPT
+from utils.storage import Storage
+from analyzers.hot_score import HotScoreCalculator
+
+
+class DestinationRanker:
+    """目的地排序器"""
+
+    def __init__(self):
+        self.settings = get_settings()
+        self.storage = Storage()
+        self.score_calculator = HotScoreCalculator()
+
+        # 初始化 Claude 客户端
+        if self.settings.anthropic_api_key:
+            self.client = Anthropic(api_key=self.settings.anthropic_api_key)
+        else:
+            self.client = None
+            print("警告：未配置 ANTHROPIC_API_KEY，将使用本地排序")
+
+    async def generate_recommendations(
+        self,
+        limit: int = 15,
+    ) -> List[DestinationRecommendation]:
+        """生成目的地推荐列表"""
+        # 1. 从数据库获取采集的数据
+        posts = await self.storage.get_recent_posts(limit=200)
+        wenlv_infos = await self.storage.get_recent_wenlv(limit=50)
+
+        # 2. 从数据中提取目的地
+        destinations = self._extract_destinations(posts, wenlv_infos)
+
+        # 3. 计算每个目的地的得分
+        scored_destinations = []
+        for dest, info in destinations.items():
+            score_info = self.score_calculator.calculate_destination_score(
+                destination=dest,
+                posts=info["posts"],
+                wenlv_infos=info["wenlv"],
+            )
+            scored_destinations.append((dest, score_info, info))
+
+        # 4. 排序
+        scored_destinations.sort(key=lambda x: x[1]["total_score"], reverse=True)
+
+        # 5. 使用 Claude 生成详细推荐（如果 API 可用）
+        if self.client:
+            return await self._generate_with_clause(
+                scored_destinations[:limit]
+            )
+        else:
+            return self._generate_local_recommendations(
+                scored_destinations[:limit]
+            )
+
+    def _extract_destinations(
+        self, posts: List[SocialPost], wenlv_infos: List[WenlvInfo]
+    ) -> Dict:
+        """从采集的数据中提取目的地"""
+        destinations = {}
+
+        # 常见旅游目的地列表
+        common_destinations = [
+            "三亚", "海口", "云南", "大理", "丽江", "香格里拉", "西双版纳",
+            "四川", "成都", "九寨沟", "川西", "稻城亚丁",
+            "北京", "上海", "广州", "深圳",
+            "浙江", "杭州", "乌镇", "普陀山",
+            "江苏", "苏州", "南京", "无锡",
+            "陕西", "西安",
+            "广西", "桂林", "阳朔",
+            "贵州", "黄果树", "西江千户苗寨",
+            "湖南", "张家界", "凤凰古城",
+            "福建", "厦门", "武夷山",
+            "海南", "三亚", "海口",
+            "西藏", "拉萨", "林芝",
+            "新疆", "喀纳斯", "伊犁",
+            "甘肃", "敦煌", "张掖",
+            "青海", "青海湖",
+            "黑龙江", "哈尔滨", "雪乡",
+            "吉林", "长白山",
+        ]
+
+        # 从帖子中提取
+        for post in posts:
+            text = f"{post.title} {post.content}"
+            for dest in common_destinations:
+                if dest in text:
+                    if dest not in destinations:
+                        destinations[dest] = {"posts": [], "wenlv": []}
+                    destinations[dest]["posts"].append(post)
+
+        # 从文旅信息中提取
+        for info in wenlv_infos:
+            region = info.region
+            if region and region != "全国":
+                if region not in destinations:
+                    destinations[region] = {"posts": [], "wenlv": []}
+                destinations[region]["wenlv"].append(info)
+
+        return destinations
+
+    async def _generate_with_clause(
+        self, scored_destinations: List[tuple]
+    ) -> List[DestinationRecommendation]:
+        """使用 Claude 生成推荐"""
+        # 构建上下文数据
+        context_data = []
+        for dest, score_info, info in scored_destinations:
+            context_data.append({
+                "name": dest,
+                "scores": score_info,
+                "post_count": len(info["posts"]),
+                "wenlv_count": len(info["wenlv"]),
+            })
+
+        # 调用 Claude API
+        prompt = DESTINATION_ANALYSIS_PROMPT.format(
+            context_data=json.dumps(context_data, ensure_ascii=False, indent=2)
+        )
+
+        try:
+            response = self.client.messages.create(
+                model="claude-sonnet-4-5",
+                max_tokens=4096,
+                messages=[
+                    {"role": "user", "content": prompt}
+                ]
+            )
+
+            # 解析响应
+            content = response.content[0].text
+            result = json.loads(content)
+
+            recommendations = []
+            for item in result.get("destinations", []):
+                rec = DestinationRecommendation(
+                    name=item.get("name", ""),
+                    rank=item.get("rank", 0),
+                    score=item.get("score", 0),
+                    reason=item.get("reason", ""),
+                    estimated_cost=item.get("estimated_cost", ""),
+                    suggested_days=item.get("suggested_days", 3),
+                    best_time=item.get("best_time", ""),
+                    highlights=item.get("highlights", []),
+                )
+                recommendations.append(rec)
+
+            return recommendations
+
+        except Exception as e:
+            print(f"Claude API 调用失败：{e}，降级为本地排序")
+            return self._generate_local_recommendations(scored_destinations)
+
+    def _generate_local_recommendations(
+        self, scored_destinations: List[tuple]
+    ) -> List[DestinationRecommendation]:
+        """本地生成推荐（不使用 AI）"""
+        recommendations = []
+
+        for i, (dest, score_info, info) in enumerate(scored_destinations):
+            # 生成推荐理由
+            reasons = []
+            if score_info["social_score"] > 7:
+                reasons.append("社交媒体热度高")
+            if score_info["policy_score"] > 7:
+                reasons.append("有政策支持")
+            if score_info["price_score"] > 7:
+                reasons.append("性价比高")
+            if score_info["seasonal_score"] > 8:
+                reasons.append("当季最佳目的地")
+
+            reason = "，".join(reasons) if reasons else "综合推荐"
+
+            # 预估价格
+            if score_info["price_score"] > 7:
+                estimated_cost = "¥2000-4000"
+            elif score_info["price_score"] > 5:
+                estimated_cost = "¥4000-6000"
+            else:
+                estimated_cost = "¥6000+"
+
+            rec = DestinationRecommendation(
+                name=dest,
+                rank=i + 1,
+                score=score_info["total_score"],
+                reason=reason,
+                estimated_cost=estimated_cost,
+                suggested_days=3 + int(score_info["seasonal_score"] / 2),
+                best_time=self._get_best_time(dest),
+                highlights=[f"热度评分：{score_info['social_score']}"],
+            )
+            recommendations.append(rec)
+
+        return recommendations
+
+    def _get_best_time(self, destination: str) -> str:
+        """获取目的地最佳旅行时间"""
+        # 简化逻辑
+        if any(kw in destination for kw in ["三亚", "海南", "西双版纳"]):
+            return "10 月 - 次年 4 月"
+        elif any(kw in destination for kw in ["哈尔滨", "雪乡", "长白山"]):
+            return "12 月 -2 月"
+        elif any(kw in destination for kw in ["婺源", "林芝"]):
+            return "3 月 -4 月"
+        elif any(kw in destination for kw in ["青海湖", "呼伦贝尔"]):
+            return "6 月 -8 月"
+        elif any(kw in destination for kw in ["九寨沟", "喀纳斯"]):
+            return "9 月 -10 月"
+        else:
+            return "春秋最佳"

package/python/analyzers/route_planner.py

@@ -0,0 +1,86 @@
+"""路线规划器 - 使用 Claude 生成详细行程"""
+import json
+from typing import List, Optional
+
+from anthropic import Anthropic
+from config.models import DestinationRecommendation, TravelRoute
+from config.settings import get_settings
+from config.prompts import ROUTE_PLANNING_PROMPT
+
+
+class RoutePlanner:
+    """旅行路线规划器"""
+
+    def __init__(self):
+        self.settings = get_settings()
+        if self.settings.anthropic_api_key:
+            self.client = Anthropic(api_key=self.settings.anthropic_api_key)
+        else:
+            self.client = None
+
+    async def plan_route(
+        self,
+        destination: DestinationRecommendation,
+    ) -> Optional[TravelRoute]:
+        """为目的地生成详细路线"""
+        if not self.client:
+            return self._generate_local_route(destination)
+
+        try:
+            prompt = ROUTE_PLANNING_PROMPT.format(
+                destination_name=destination.name,
+                days=destination.suggested_days,
+                highlights=json.dumps(destination.highlights, ensure_ascii=False),
+            )
+
+            response = self.client.messages.create(
+                model="claude-sonnet-4-5",
+                max_tokens=4096,
+                messages=[{"role": "user", "content": prompt}]
+            )
+
+            content = response.content[0].text
+            route_data = json.loads(content)
+
+            return TravelRoute(
+                destination=route_data.get("destination", destination.name),
+                duration_days=route_data.get("duration_days", destination.suggested_days),
+                daily_plan=route_data.get("daily_plan", []),
+                budget_estimate=route_data.get("budget_estimate", {}),
+            )
+
+        except Exception as e:
+            print(f"路线规划失败：{e}")
+            return self._generate_local_route(destination)
+
+    def _generate_local_route(self, dest: DestinationRecommendation) -> TravelRoute:
+        """本地生成简单路线"""
+        days = dest.suggested_days
+        daily_plan = []
+
+        for i in range(days):
+            day_plan = {
+                "day": i + 1,
+                "theme": f"第{i + 1}天探索",
+                "activities": [
+                    {"time": "上午", "item": "景点游览", "duration": "3 小时"},
+                    {"time": "下午", "item": "深度体验", "duration": "4 小时"},
+                    {"time": "晚上", "item": "美食探索", "duration": "2 小时"},
+                ],
+                "food_recommendation": "当地特色美食",
+                "accommodation_area": "市中心/景区附近",
+            }
+            daily_plan.append(day_plan)
+
+        return TravelRoute(
+            destination=dest.name,
+            duration_days=days,
+            daily_plan=daily_plan,
+            budget_estimate={
+                "accommodation": "¥300-500/晚",
+                "food": "¥100-200/天",
+                "transport": "¥50-100/天",
+                "activities": "¥100-300/天",
+                "total": f"¥{500 * days}-{1100 * days}",
+            },
+        )