#!/usr/bin/env python3 """ Feishu Smart Doc Writer - 改进版 自动分块写入 + 自动转移所有权 + 自动更新索引 """ import re import time import json import asyncio from typing import List, Optional from dataclasses import dataclass # 导入索引管理器 try: from .index_manager import IndexManager, add_doc_to_index except ImportError: from index_manager import IndexManager, add_doc_to_index @dataclass class ChunkConfig: """分块配置""" chunk_size: int = 2000 # 每块最大字符数 max_retries: int = 3 # 最大重试次数 retry_delay: float = 1.0 # 重试间隔（秒） show_progress: bool = True # 显示进度 convert_tables: bool = True # 转换表格为文本 class ContentChunker: """内容分块器""" def __init__(self, config: ChunkConfig = None): self.config = config or ChunkConfig() def chunk_content(self, content: str) -> List[str]: """ 将长内容分割成多个小块 策略：按段落分割，如果段落超过限制，按句子分割 """ chunks = [] current_chunk = "" # 先处理表格 if self.config.convert_tables: content = self._convert_tables(content) # 按段落分割 paragraphs = self._split_paragraphs(content) for para in paragraphs: # 如果当前块加上新段落会超限 if len(current_chunk) + len(para) > self.config.chunk_size: # 保存当前块 if current_chunk.strip(): chunks.append(current_chunk.strip()) # 如果单个段落就超限，需要进一步分割 if len(para) > self.config.chunk_size: sub_chunks = self._split_large_paragraph(para) chunks.extend(sub_chunks) current_chunk = "" else: current_chunk = para else: current_chunk += "\n\n" + para if current_chunk else para # 保存最后一块 if current_chunk.strip(): chunks.append(current_chunk.strip()) return chunks def _convert_tables(self, content: str) -> str: """将Markdown表格转换为文本列表""" table_pattern = r'\|[^\n]+\|\n\|[-:| ]+\|\n((?:\|[^\n]+\|\n)+)' def convert_table(match): table_text = match.group(0) lines = table_text.strip().split('\n') # 提取表头 header = [cell.strip() for cell in lines[0].split('|')[1:-1]] # 提取数据行 result = ["【表格内容】"] for line in lines[2:]: # 跳过表头和分隔线 cells = [cell.strip() for cell in line.split('|')[1:-1]] if cells and any(cells): # 确保不是空行 row_text = ", ".join([f"{h}: {c}" for h, c in zip(header, cells)]) result.append(f"- {row_text}") return "\n".join(result) return re.sub(table_pattern, convert_table, content) def _split_paragraphs(self, content: str) -> List[str]: """按段落分割，保留标题结构""" lines = content.split('\n') paragraphs = [] current_para = "" for line in lines: stripped = line.strip() if not stripped: if current_para.strip(): paragraphs.append(current_para.strip()) current_para = "" continue # 如果是标题，单独成段 if stripped.startswith('#'): if current_para.strip(): paragraphs.append(current_para.strip()) current_para = "" paragraphs.append(stripped) else: current_para += line + "\n" if current_para.strip(): paragraphs.append(current_para.strip()) return paragraphs def _split_large_paragraph(self, para: str) -> List[str]: """分割大段落（按句子）""" chunks = [] sentences = re.split(r'([。！？.\n])', para) current = "" for i in range(0, len(sentences), 2): sentence = sentences[i] if i + 1 < len(sentences): sentence += sentences[i + 1] # 加上标点 if len(current) + len(sentence) > self.config.chunk_size: if current.strip(): chunks.append(current.strip()) current = sentence else: current += sentence if current.strip(): chunks.append(current.strip()) return chunks class FeishuDocWriter: """ 飞书文档智能写入器 使用 OpenClaw 官方工具调用方式 """ def __init__(self, ctx=None, config: ChunkConfig = None): """ 初始化 Args: ctx: OpenClaw 上下文对象（在 Skill 中传入） config: 分块配置 """ self.ctx = ctx self.config = config or ChunkConfig() self.chunker = ContentChunker(config) async def write_document(self, title: str, content: str, folder_token: str = None) -> str: """ 创建新文档并写入内容（自动分块） Args: title: 文档标题 content: 文档内容（支持长内容，自动分块） folder_token: 可选的文件夹token Returns: 文档URL """ if not self.ctx: raise ValueError("需要提供 OpenClaw 上下文对象 (ctx)") # 第一步：创建空文档（只传标题） doc_token = await self._create_empty_doc(title, folder_token) doc_url = f"https://feishu.cn/docx/{doc_token}" if self.config.show_progress: print(f"✅ 文档创建成功: {doc_url}") # 第二步：分批追加内容 success = await self._write_content_in_chunks(doc_token, content) if not success: raise Exception("写入内容失败") return doc_url async def append_to_document(self, doc_url: str, content: str) -> bool: """ 追加内容到现有文档（自动分块） Args: doc_url: 文档URL content: 要追加的内容 Returns: 是否成功 """ if not self.ctx: raise ValueError("需要提供 OpenClaw 上下文对象 (ctx)") doc_token = self._extract_token_from_url(doc_url) return await self._write_content_in_chunks(doc_token, content) async def _create_empty_doc(self, title: str, folder_token: str = None) -> str: """创建空文档，只传标题""" try: # 使用 OpenClaw 官方工具调用方式 result = await self.ctx.invoke_tool("feishu_doc.create", { "title": title, "folder_token": folder_token }) # 提取 doc_token if isinstance(result, dict): doc_token = result.get("document_id") or result.get("doc_token") if doc_token: return doc_token # 如果是字符串，尝试提取 if isinstance(result, str): import re match = re.search(r'docx/([a-zA-Z0-9]+)', result) if match: return match.group(1) return result raise Exception(f"无法解析文档token: {result}") except Exception as e: raise Exception(f"创建文档失败: {e}") async def _write_content_in_chunks(self, doc_token: str, content: str) -> bool: """分批写入内容""" chunks = self.chunker.chunk_content(content) if self.config.show_progress: print(f"📝 内容已分割为 {len(chunks)} 块，开始写入...") for i, chunk in enumerate(chunks, 1): if self.config.show_progress: print(f" 写入第 {i}/{len(chunks)} 块 ({len(chunk)} 字符)...") success = await self._append_chunk_with_retry(doc_token, chunk) if not success: print(f"❌ 第 {i} 块写入失败") return False # 添加小延迟，避免API限流 if i < len(chunks): await asyncio.sleep(0.5) if self.config.show_progress: print(f"✅ 全部 {len(chunks)} 块写入完成") return True async def _append_chunk_with_retry(self, doc_token: str, chunk: str) -> bool: """带重试的追加内容""" for attempt in range(self.config.max_retries): try: return await self._append_chunk(doc_token, chunk) except Exception as e: if self.config.show_progress: print(f" 尝试 {attempt + 1}/{self.config.max_retries} 失败: {e}") if attempt < self.config.max_retries - 1: await asyncio.sleep(self.config.retry_delay * (attempt + 1)) else: return False return False async def _append_chunk(self, doc_token: str, chunk: str) -> bool: """追加单块内容""" try: # 使用 OpenClaw 官方工具调用方式 await self.ctx.invoke_tool("feishu_doc.append", { "doc_token": doc_token, "content": chunk }) return True except Exception as e: raise Exception(f"API调用失败: {e}") def _extract_token_from_url(self, url: str) -> str: """从URL中提取doc_token""" import re match = re.search(r'docx/([a-zA-Z0-9]+)', url) if match: return match.group(1) raise ValueError(f"无法从URL提取token: {url}") async def _get_tenant_access_token(self) -> str: """获取飞书 tenant_access_token""" import aiohttp import json import os # 尝试从 OpenClaw 配置读取 App ID 和 Secret app_id, app_secret = None, None # 方法1: 尝试从环境变量读取 app_id = os.environ.get("FEISHU_APP_ID") app_secret = os.environ.get("FEISHU_APP_SECRET") # 方法2: 尝试从 OpenClaw 配置文件读取 if not app_id or not app_secret: try: config_paths = [ os.path.expanduser("~/.openclaw/openclaw.json"), os.path.expanduser("~/.openclaw/config.json"), ] for config_path in config_paths: if os.path.exists(config_path): with open(config_path, 'r') as f: config = json.load(f) feishu_config = config.get("channels", {}).get("feishu", {}) app_id = feishu_config.get("appId") app_secret = feishu_config.get("appSecret") if app_id and app_secret: break except Exception: pass if not app_id or not app_secret: return "" # 调用飞书 API 获取 token url = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal" payload = { "app_id": app_id, "app_secret": app_secret } try: async with aiohttp.ClientSession() as session: async with session.post(url, json=payload) as resp: result = await resp.json() if result.get("code") == 0: return result.get("tenant_access_token", "") except Exception: pass return "" async def transfer_ownership(self, doc_url: str, owner_openid: str) -> bool: """ 转移文档所有权 - 直接调用飞书 API API端点: POST /drive/v1/permissions/{token}/members/transfer_owner?type=docx Args: doc_url: 文档URL owner_openid: 新所有者的openid (例如: ou_xxxxxxxx) Returns: 是否成功 """ import aiohttp import json doc_token = self._extract_token_from_url(doc_url) # 获取 tenant_access_token token = await self._get_tenant_access_token() if not token: if self.config.show_progress: print(f"⚠️ 无法获取 tenant_access_token") return False # 调用飞书 API 转移所有权 url = f"https://open.feishu.cn/open-apis/drive/v1/permissions/{doc_token}/members/transfer_owner?type=docx" headers = { "Authorization": f"Bearer {token}", "Content-Type": "application/json" } payload = { "member_type": "openid", "member_id": owner_openid } try: async with aiohttp.ClientSession() as session: async with session.post(url, headers=headers, json=payload) as resp: result = await resp.json() if result.get("code") == 0: if self.config.show_progress: print(f"✅ 文档所有权已转移给 {owner_openid}") return True else: error_msg = result.get("msg", "未知错误") if self.config.show_progress: print(f"⚠️ 所有权转移失败: {error_msg}") return False except Exception as e: if self.config.show_progress: print(f"⚠️ 所有权转移失败: {e}") return False async def write_document_with_transfer( self, title: str, content: str, folder_token: str = None, owner_openid: str = None ) -> dict: """ 创建文档并写入内容，完成后自动转移所有权并更新本地索引 Args: title: 文档标题 content: 文档内容 folder_token: 可选的文件夹token owner_openid: 新所有者的openid，如果提供则自动转移所有权 Returns: { "doc_url": "...", "doc_token": "...", "chunks_count": N, "owner_transferred": True/False, "index_updated": True/False } """ # 1. 创建并写入文档 doc_url = await self.write_document(title, content, folder_token) # 2. 提取 doc_token doc_token = self._extract_token_from_url(doc_url) # 3. 计算分块数 chunks = self.chunker.chunk_content(content) # 4. 转移所有权（如果提供了 owner_openid） owner_transferred = False if owner_openid: owner_transferred = await self.transfer_ownership(doc_url, owner_openid) # 5. 【关键】自动更新本地索引 index_updated = False try: # 生成摘要（取前100字） summary = content[:100].replace('\n', ' ') + "..." if len(content) > 100 else content # 自动分类标签 tags = self._auto_classify_content(content, title) # 更新索引 index_updated = add_doc_to_index( name=title, url=doc_url, token=doc_token, summary=summary, tags=tags, owner=owner_openid or "" ) if self.config.show_progress and index_updated: print(f"✅ 文档索引已更新") elif self.config.show_progress: print(f"⚠️ 文档索引更新失败（不影响文档创建）") except Exception as e: if self.config.show_progress: print(f"⚠️ 索引更新失败: {e}（不影响文档创建）") return { "doc_url": doc_url, "doc_token": doc_token, "chunks_count": len(chunks), "owner_transferred": owner_transferred, "index_updated": index_updated } def _auto_classify_content(self, content: str, title: str) -> List[str]: """根据内容自动分类""" tags = [] text = (title + " " + content).lower() # 关键词映射到标签 if any(k in text for k in ["ai", "人工智能", "模型", "gpt", "llm"]): tags.append("AI技术") if any(k in text for k in ["openclaw", "skill", "agent"]): tags.append("OpenClaw") if any(k in text for k in ["飞书", "文档", "feishu", "docx"]): tags.append("飞书文档") if any(k in text for k in ["电商", "tiktok", "alibaba", "玩具"]): tags.append("电商") if any(k in text for k in ["garmin", "strava", "骑行", "健康", "运动"]): tags.append("健康运动") if any(k in text for k in ["对话", "归档", "聊天记录"]): tags.append("每日归档") # 如果没有匹配到特定标签，添加通用标签 if not tags: tags.append("其他") return tags # 同步包装函数（方便非异步环境使用） def write_document_sync(ctx, title: str, content: str, folder_token: str = None, config: ChunkConfig = None) -> str: """同步方式写入文档""" writer = FeishuDocWriter(ctx, config) return asyncio.run(writer.write_document(title, content, folder_token)) def write_document_with_transfer_sync( ctx, title: str, content: str, folder_token: str = None, owner_openid: str = None, config: ChunkConfig = None ) -> dict: """同步方式写入文档并转移所有权""" writer = FeishuDocWriter(ctx, config) return asyncio.run(writer.write_document_with_transfer(title, content, folder_token, owner_openid)) def append_to_document_sync(ctx, doc_url: str, content: str, config: ChunkConfig = None) -> bool: """同步方式追加文档""" writer = FeishuDocWriter(ctx, config) return asyncio.run(writer.append_to_document(doc_url, content))