# config/skills.yaml
skills:
  - path: "./skills/intent-classifier"
    enabled: true
  - path: "./skills/faq-answer"
    enabled: true
  - path: "./skills/human-handoff"
    enabled: true
  - path: "./skills/ticket-manager"
    enabled: true

// skills/intent-classifier/index.js
module.exports = {
  name: 'intent-classifier',
  description: '客户意图识别',

  async execute(params, context) {
    const { message } = params;

    // 使用 LLM 分析用户意图
    const result = await context.llm.classify({
      text: message,
      categories: [
        'product_inquiry',    // 产品咨询
        'technical_support',   // 技术支持
        'billing',            // 账单问题
        'complaint',          // 投诉
        'feedback',           // 反馈建议
        'general',            // 一般咨询
        'human_agent'         // 转人工
      ]
    });

    return {
      type: 'json',
      data: {
        intent: result.category,
        confidence: result.confidence,
        entities: result.entities
      }
    };
  }
};

// skills/faq-answer/index.js
const knowledgeBase = [
  {
    keywords: ['价格', '收费', '费用'],
    answer: '我们的定价分为三档：基础版免费，专业版每月99元，企业版每月299元。'
  },
  {
    keywords: ['如何', '使用', '教程'],
    answer: '您可以在我们的帮助中心查看详细教程：https://help.example.com'
  },
  {
    keywords: ['退款', '取消'],
    answer: '我们提供7天无理由退款服务。您可以在设置-账户中申请退款。'
  }
];

module.exports = {
  name: 'faq-answer',
  description: 'FAQ 自动回复',

  async execute(params, context) {
    const { message } = params;

    // 关键词匹配
    for (const faq of knowledgeBase) {
      if (faq.keywords.some(k => message.includes(k))) {
        return {
          type: 'text',
          content: faq.answer,
          metadata: { source: 'faq' }
        };
      }
    }

    // 未匹配到 FAQ，返回 null 让其他技能处理
    return null;
  }
};

// skills/ticket-manager/index.js
module.exports = {
  name: 'ticket-manager',
  description: '工单管理系统',

  async execute(params, context) {
    const { action, ticketId, data } = params;

    switch (action) {
      case 'create':
        const ticket = await context.tickets.create({
          title: data.title,
          description: data.description,
          priority: data.priority || 'medium',
          category: data.category,
          customerId: context.user.id,
          status: 'open'
        });

        return {
          type: 'text',
          content: `✅ 工单已创建：#${ticket.id}\n标题：${ticket.title}\n优先级：${ticket.priority}`
        };

      case 'status':
        const status = await context.tickets.getStatus(ticketId);
        return {
          type: 'text',
          content: `工单 #${ticketId} 状态：${status}`
        };

      case 'resolve':
        await context.tickets.resolve(ticketId, {
          solution: data.solution,
          resolvedBy: 'system'
        });

        return {
          type: 'text',
          content: `✅ 工单 #${ticketId} 已标记为已解决`
        };
    }
  }
};

// skills/approval-workflow/index.js
const approvalRules = {
  'leave_request': {
    approvers: ['manager1', 'manager2'],
    conditions: [
      { field: 'days', operator: '>', value: 3, require: 'department_head' }
    ],
    autoApprove: { field: 'days', operator: '<=', value: 1 }
  },
  'expense': {
    approvers: ['finance1'],
    conditions: [
      { field: 'amount', operator: '>=', value: 10000, require: 'cfo' }
    ],
    autoApprove: { field: 'amount', operator: '<', value: 1000 }
  },
  'purchase': {
    approvers: ['procurement1'],
    conditions: [
      { field: 'amount', operator: '>=', value: 50000, require: 'ceo' }
    ]
  }
};

module.exports = {
  name: 'approval-workflow',
  description: '审批工作流',

  async execute(params, context) {
    const { type, data, action } = params;

    switch (action) {
      case 'submit':
        return await this.submitApproval(type, data, context);
      case 'approve':
        return await this.approveRequest(type, data, context);
      case 'reject':
        return await this.rejectRequest(type, data, context);
    }
  },

  async submitApproval(type, data, context) {
    const rule = approvalRules[type];
    if (!rule) {
      return { type: 'text', content: '未知的审批类型' };
    }

    // 自动审批检查
    if (rule.autoApprove) {
      const { field, operator, value } = rule.autoApprove;
      if (eval(`${data[field]} ${operator} ${value}`)) {
        await this.autoApprove(type, data);
        return { type: 'text', content: '✅ 申请已自动批准' };
      }
    }

    // 确定审批人
    let approvers = [...rule.approvers];
    for (const condition of rule.conditions) {
      if (eval(`${data[condition.field]} ${condition.operator} ${condition.value}`)) {
        approvers.push(condition.require);
      }
    }

    // 创建审批单
    const approval = await context.approvals.create({
      type,
      data,
      approvers: [...new Set(approvers)],
      status: 'pending',
      submitter: context.user.id
    });

    // 通知审批人
    for (const approver of approvers) {
      await context.notifications.send({
        to: approver,
        title: '新的审批请求',
        content: `您有一个新的${type}审批请求`,
        link: `/approvals/${approval.id}`
      });
    }

    return {
      type: 'text',
      content: `✅ 审批请求已提交，等待审批人处理\n审批人：${approvers.join('、')}`
    };
  }
};

# config/cron.yaml
tasks:
  # 每日销售数据收集
  - name: "daily-sales-collection"
    schedule: "0 23 * * *"
    skill: "data-collector"
    params:
      sources:
        - name: "crm"
          api: "https://crm.example.com/api/sales"
        - name: "ecommerce"
          api: "https://shop.example.com/api/orders"

  # 每周数据汇总
  - name: "weekly-data-summary"
    schedule: "0 18 * * 5"
    skill: "data-summarizer"
    params:
      type: "weekly"

// skills/data-collector/index.js
module.exports = {
  name: 'data-collector',
  description: '数据收集',

  async execute(params, context) {
    const { sources } = params;
    const results = [];

    for (const source of sources) {
      try {
        const data = await context.http.get(source.api, {
          headers: {
            Authorization: `Bearer ${process.env.API_TOKEN}`
          },
          params: {
            date: new Date().toISOString().split('T')[0]
          }
        });

        results.push({
          source: source.name,
          status: 'success',
          data
        });
      } catch (error) {
        results.push({
          source: source.name,
          status: 'failed',
          error: error.message
        });
      }
    }

    // 存储收集的数据
    await context.storage.save({
      key: `data_collection_${Date.now()}`,
      value: results
    });

    const failed = results.filter(r => r.status === 'failed');

    return {
      type: 'text',
      content: `📊 数据收集完成\n成功：${results.length - failed.length}/${results.length}` +
        (failed.length > 0 ? `\n失败：${failed.map(f => f.source).join('、')}` : '')
    };
  }
};

// skills/report-generator/index.js
module.exports = {
  name: 'report-generator',
  description: '报告生成',

  async execute(params, context) {
    const { type, period, recipients, format = 'markdown' } = params;

    // 获取数据
    const data = await this.fetchData(type, period);

    // 生成报告
    let report;
    switch (type) {
      case 'sales':
        report = await this.generateSalesReport(data, period);
        break;
      case 'operations':
        report = await this.generateOpsReport(data, period);
        break;
      case 'customer':
        report = await this.generateCustomerReport(data, period);
        break;
      default:
        report = await this.generateGenericReport(data, period);
    }

    // 发送报告
    for (const recipient of recipients) {
      await this.sendReport(recipient, report, format);
    }

    return {
      type: 'text',
      content: `📊 ${type}报告已生成并发送给 ${recipients.length} 位收件人`
    };
  },

  async fetchData(type, period) {
    // 根据类型和周期获取数据
    const query = {
      type,
      startDate: period.start,
      endDate: period.end
    };

    return await context.database.query(query);
  },

  async generateSalesReport(data, period) {
    const total = data.reduce((sum, d) => sum + d.amount, 0);
    const count = data.length;
    const avg = count > 0 ? total / count : 0;

    return `
# 销售报告 (${period.start} - ${period.end})

## 概览
- 总销售额：¥${total.toLocaleString()}
- 订单数量：${count}
- 平均订单金额：¥${avg.toFixed(2)}

## 详细数据
${data.map(d => `- ${d.date}: ¥${d.amount} - ${d.product}`).join('\n')}

---
由 OpenClaw 自动生成
`;
  }
};

tasks:
  # 每日销售报告
  - name: "daily-sales-report"
    schedule: "0 8 * * *"
    skill: "report-generator"
    params:
      type: "sales"
      period: "yesterday"
      recipients:
        - type: "email"
          address: "sales@example.com"
        - type: "telegram"
          userId: "123456"

  # 每周运营报告
  - name: "weekly-ops-report"
    schedule: "0 9 * * 1"
    skill: "report-generator"
    params:
      type: "operations"
      period: "last_week"
      recipients:
        - type: "email"
          address: "ops@example.com"

  # 每月客户分析
  - name: "monthly-customer-report"
    schedule: "0 9 1 * *"
    skill: "report-generator"
    params:
      type: "customer"
      period: "last_month"
      recipients:
        - type: "email"
          address: "crm@example.com"

// skills/task-assigner/index.js
const assignmentRules = [
  {
    condition: { category: 'bug', severity: 'high' },
    assignTo: { type: 'skill', value: 'senior-devs' },
    priority: 1
  },
  {
    condition: { category: 'feature', complexity: 'high' },
    assignTo: { type: 'skill', value: 'tech-leads' },
    priority: 2
  },
  {
    condition: { category: 'documentation' },
    assignTo: { type: 'round-robin', value: 'technical-writers' },
    priority: 3
  }
];

module.exports = {
  name: 'task-assigner',
  description: '智能任务分配',

  async execute(params, context) {
    const { task } = params;

    // 找到匹配的规则
    for (const rule of assignmentRules) {
      if (this.matchCondition(task, rule.condition)) {
        const assignee = await this.resolveAssignee(rule.assignTo, task);

        await context.tasks.assign({
          taskId: task.id,
          assignee,
          priority: rule.priority
        });

        // 通知被分配人
        await context.notifications.send({
          to: assignee,
          title: `新任务分配：${task.title}`,
          content: task.description
        });

        return {
          type: 'text',
          content: `✅ 任务已分配给 ${assignee}`
        };
      }
    }

    // 默认分配
    const defaultAssignee = await this.getDefaultAssignee();
    await context.tasks.assign({ taskId: task.id, assignee: defaultAssignee });

    return { type: 'text', content: '任务已分配' };
  },

  matchCondition(task, condition) {
    return Object.entries(condition).every(
      ([key, value]) => task[key] === value
    );
  }
};

# 工作流配置
workflows:
  - name: "employee-onboarding"
    version: "1.0.0"
    description: "新员工入职流程自动化"

    triggers:
      - type: "event"
        event: "hr.new_employee"

    steps:
      # 步骤1：创建账号
      - name: "create_account"
        skill: "account-creator"
        params:
          type: "employee"
        onSuccess: "setup_email"

      # 步骤2：配置邮箱
      - name: "setup_email"
        skill: "email-setup"
        params:
          template: "standard"
        onSuccess: "provision_software"
        onFailure: "notify_it"

      # 步骤3：分配软件
      - name: "provision_software"
        skill: "software-provisioner"
        params:
          packages:
            - "office"
            - "communication"
            - "development"
        onSuccess: "send_welcome"

      # 步骤4：发送欢迎邮件
      - name: "send_welcome"
        skill: "welcome-mailer"
        onSuccess: "notify_manager"

      # 步骤5：通知直属经理
      - name: "notify_manager"
        skill: "notification-sender"

// 批量处理提高效率
const batchSize = 100;
for (let i = 0; i < items.length; i += batchSize) {
  const batch = items.slice(i, i + batchSize);
  await Promise.all(batch.map(item => processItem(item)));
}

// 缓存常用数据
const cacheKey = `report:${type}:${period}`;
const cached = await context.cache.get(cacheKey);

if (cached) {
  return cached;
}

const report = await generateReport(type, period);
await context.cache.set(cacheKey, report, 3600);

return report;

// 并行获取多个数据源
const [sales, marketing, support] = await Promise.all([
  fetchSalesData(),
  fetchMarketingData(),
  fetchSupportData()
]);

security:
  # 审批权限
  approval:
    requireApproval: true
    roles:
      - name: "finance"
        canApprove: ["expense", "budget"]
      - name: "hr"
        canApprove: ["leave", "onboarding"]

  # 数据访问
  dataAccess:
    # 敏感字段脱敏
    maskFields:
      - "password"
      - "creditCard"
      - "ssn"

audit:
  enabled: true
  logLevel: "info"

  # 记录所有敏感操作
  events:
    - "approval.*"
    - "data.export"
    - "user.*"

  retentionDays: 365