┌─────────────────────────────────────────────────────────────┐
│                        生活工作台                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐  │
│   │ 邮件流  │   │ 日程流  │   │ 内容流  │   │ 数据流  │  │
│   │ 邮件→分类│   │ 日程→提醒│   │ 热点→发布│   │ 数据→报表│  │
│   │       →回复│   │       →协调│   │       →监控│   │       →洞察│  │
│   └─────────┘   └─────────┘   └─────────┘   └─────────┘  │
│                                                             │
└─────────────────────────────────────────────────────────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │   OpenCLAW      │
                    │   核心引擎      │
                    └─────────────────┘

from openclaw import WorkflowEngine

# 创建工作流引擎
engine = WorkflowEngine()

# 定义工作流
@engine.workflow("daily_routine")
async def daily_routine():
    # 早上 8 点执行
    await run_at("08:00", [
        check_important_emails(),
        review_today_schedule(),
        fetch_trending_topics()
    ])

    # 下午 2 点执行
    await run_at("14:00", [
        generate_content(),
        reply_messages()
    ])

    # 晚上 8 点执行
    await run_at("20:00", [
        generate_daily_report(),
        prepare_tomorrow()
    ])

# 邮件工作流
@engine.workflow("email_flow")
async def email_flow():
    # 获取新邮件
    emails = await email_client.fetch_unread()

    for email in emails:
        # 分类
        category = classify_email(email)

        # 存入对应文件夹
        await email.move_to(email.id, category)

        # 重要邮件自动回复
        if category == "important":
            draft = await ai.generate_reply(email)
            await email.save_draft(email.id, draft)

            # 通知我
            await notify(f"重要邮件：{email.subject}")

# 定时执行
@scheduler.every(minutes=30)
async def check_emails():
    await engine.run("email_flow")

# 日程工作流
@engine.workflow("schedule_flow")
async def schedule_flow():
    # 获取今天日程
    events = await calendar.get_today()

    # 设置提醒
    for event in events:
        await remind_at(
            time=event.start - timedelta(minutes=30),
            message=f"30分钟后：{event.title}"
        )

    # 检查冲突
    conflicts = await calendar.check_conflicts(events)
    if conflicts:
        await notify(f"日程冲突：{conflicts}")

    # 自动安排空闲时间
    free_slots = await calendar.find_free_slots(today)
    await db.save("free_slots", free_slots)

# 智能日程建议
@engine.workflow("smart_schedule")
async def smart_schedule():
    # 分析最近日程模式
    patterns = await analyze_schedule_patterns()

    # 建议最佳时间
    suggestions = await suggest_best_times(
        task="deep_work",
        duration=2,
        patterns=patterns
    )

    await notify(f"建议深度工作时间：{suggestions}")

# 邮件分类规则
CATEGORIES = {
    "重要": ["客户", "订单", "付款", "紧急"],
    "工作": ["会议", "项目", "报告", "周报"],
    "订阅": ["newsletter", "更新", "周刊"],
    "广告": ["优惠", "促销", "限时"]
}

async def classify_email(email):
    content = f"{email.subject} {email.body}"

    for category, keywords in CATEGORIES.items():
        if any(kw in content for kw in keywords):
            return category

    return "其他"

# 自动日程协调
@engine.workflow("meeting_coordinator")
async def coordinate_meeting(request):
    # 分析参与者的空闲时间
    participants = request.participants
    availability = await calendar.get_availability(participants)

    # 找到共同空闲时间
    common_slots = find_common_slots(availability)

    # 自动发送邀请
    for slot in common_slots[:3]:
        await calendar.send_invite(
            time=slot,
            participants=participants,
            title=request.title
        )

    # 通知结果
    await notify(f"已发送 {len(common_slots[:3])} 个时间段邀请")

# 内容工作流
@engine.workflow("content_flow")
async def content_flow():
    # 追踪热点
    trending = await tracker.get_trending()

    # 生成内容
    for topic in trending[:3]:
        article = await generator.generate(topic)

        # 质量检查
        if quality_check(article):
            await publisher.schedule(
                content=article,
                publish_time=get_best_publish_time()
            )

    # 通知
    await notify(f"已生成并安排 {len(trending[:3])} 篇内容")

# 数据工作流
@engine.workflow("data_summary")
async def data_summary():
    # 收集数据
    data = {
        "邮件": await email_client.stats(),
        "日程": await calendar.stats(),
        "内容": await publisher.stats(),
        "收入": await finance.stats()
    }

    # 生成报告
    report = await generate_report(data)

    # 发送报告
    await send_report(report)

    # 存档
    await db.save("daily_reports", report)

# 条件工作流
@engine.workflow("conditional_flow")
@trigger("收到付款邮件")
async def payment_flow(email):
    # 自动创建收入记录
    await finance.record_income(email)

    # 发送感谢邮件
    await email.send_thank_you(email.sender)

    # 更新项目状态
    await project.update_status(email.project_id, "paid")

    # 通知我
    await notify(f"新收入：{email.amount}")

# 跨平台同步
@engine.workflow("sync_all")
async def sync_all():
    # 从 Notion 同步到 Obsidian
    notes = await notion.fetch_notes()
    await obsidian.sync(notes)

    # 从 Google Calendar 同步到企业微信
    events = await google_calendar.fetch_events()
    await wecom_calendar.sync(events)

    # 从 Evernote 同步到 Notion
    notes = await evernote.fetch_notes()
    await notion.sync(notes)

# AI 建议
@engine.workflow("ai_suggestions")
async def ai_suggestions():
    # 分析近期行为
    behaviors = await analyze_behaviors(days=30)

    # 生成优化建议
    suggestions = await ai.suggest_optimizations(behaviors)

    # 发送建议
    await notify(suggestions)