myagent-ai 1.17.3 → 1.18.0

package/core/deps_checker.py

@@ -68,14 +68,20 @@ DEPENDENCIES: List[DepInfo] = [
     # ── PDF 处理 ──
     DepInfo("PyPDF2", "PyPDF2", "3.0.0", "pdf", "all",
             note="纯 Python PDF 文本提取（pdftotext 失败时的备用方案）"),
+    DepInfo("pypdf", "pypdf", "4.0.0", "pdf", "all",
+            note="PDF 文本提取 (PyPDF2 新版, 优先使用)"),
+    DepInfo("reportlab", "reportlab", "4.0.0", "pdf", "all",
+            note="PDF 文档生成引擎"),
+    DepInfo("PIL", "Pillow", "10.0.0", "pdf", "all",
+            note="图片处理 (PDF 插图, 报告图表)"),
 
     # ── 文档处理 (Excel/Word/PPT) ──
     DepInfo("openpyxl", "openpyxl", "3.1.0", "doc", "all",
-            note="Excel (.xlsx) 文件读取"),
+            note="Excel (.xlsx) 文件读取和生成"),
     DepInfo("docx", "python-docx", "1.1.0", "doc", "all",
-            note="Word (.docx) 文件读取"),
+            note="Word (.docx) 文件读取和生成"),
     DepInfo("pptx", "python-pptx", "0.6.21", "doc", "all",
-            note="PowerPoint (.pptx) 文件读取"),
+            note="PowerPoint (.pptx) 文件读取和生成"),
     DepInfo("xlrd", "xlrd", "2.0.0", "doc", "all",
             note="旧版 Excel (.xls) 文件读取"),
 

package/main.py

@@ -390,6 +390,19 @@ class MyAgentApp:
         ]:
             self.skill_registry.register(skill_cls())
 
+        # ── 文档生成技能 (v1.17.3, 融合 MiniMax Skills 设计理念) ──
+        from skills.pdf_skill import PDFCreateSkill, PDFReadSkill
+        from skills.docx_skill import DOCXCreateSkill, DOCXReadSkill
+        from skills.xlsx_skill import XLSXCreateSkill, XLSXReadSkill, XLSXEditSkill
+        from skills.ppt_skill import PPTCreateSkill, PPTReadSkill
+        for skill_cls in [
+            PDFCreateSkill, PDFReadSkill,
+            DOCXCreateSkill, DOCXReadSkill,
+            XLSXCreateSkill, XLSXReadSkill, XLSXEditSkill,
+            PPTCreateSkill, PPTReadSkill,
+        ]:
+            self.skill_registry.register(skill_cls())
+
     async def process_message(
         self,
         user_message: str,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.17.3",
+  "version": "1.18.0",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/skills/docx_skill.py

@@ -0,0 +1,199 @@
+"""
+skills/docx_skill.py - DOCX Word 文档生成/编辑技能
+===============================================
+基于 python-docx 生成和编辑 Word 文档，融入 MiniMax DOCX Skill 设计理念。
+支持标题、段落、列表、表格、图片、页眉页脚、样式等。
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from skills.base import Skill, SkillParameter, SkillResult
+
+
+class DOCXCreateSkill(Skill):
+    """生成 Word 文档"""
+    name = "docx_create"
+    description = (
+        "生成 Word (DOCX) 文档。支持多级标题、段落、列表、表格、图片等。"
+        "content 为 JSON 数组，每项: {type, text/items/headers/rows/path...}。"
+        "type 可选: h1/h2/h3/body/bullet/numbered/table/image/pagebreak/spacer。"
+    )
+    category = "doc"
+    dangerous = True
+    parameters = [
+        SkillParameter("content", "string",
+            "内容块 JSON 数组。示例: [{\"type\":\"h1\",\"text\":\"报告\"},{\"type\":\"body\",\"text\":\"正文\"}]",
+            required=True),
+        SkillParameter("output_path", "string", "输出 DOCX 文件路径", required=True),
+        SkillParameter("title", "string", "文档标题", required=False, default=""),
+        SkillParameter("author", "string", "作者", required=False, default=""),
+        SkillParameter("font", "string", "中文字体", required=False, default="SimHei"),
+    ]
+
+    async def execute(self, content: str = "", output_path: str = "",
+                      title: str = "", author: str = "",
+                      font: str = "SimHei", **kwargs) -> SkillResult:
+        try:
+            from docx import Document
+            from docx.shared import Inches, Cm, Pt, Emu, RGBColor
+            from docx.enum.text import WD_ALIGN_PARAGRAPH
+            from docx.enum.table import WD_TABLE_ALIGNMENT
+        except ImportError:
+            return SkillResult(success=False, error="python-docx 未安装: pip install python-docx")
+
+        try:
+            blocks = json.loads(content) if isinstance(content, str) else content
+            if not isinstance(blocks, list):
+                blocks = [{"type": "body", "text": str(blocks)}]
+        except json.JSONDecodeError as e:
+            return SkillResult(success=False, error=f"content JSON 解析失败: {e}")
+
+        try:
+            out = Path(output_path).expanduser().resolve()
+            out.parent.mkdir(parents=True, exist_ok=True)
+
+            doc = Document()
+            if title:
+                doc.core_properties.title = title
+            if author:
+                doc.core_properties.author = author
+
+            style = doc.styles["Normal"]
+            rpr = style.font
+            rpr.name = font
+            rpr.size = Pt(11)
+
+            for level, size in [("Heading 1", 22), ("Heading 2", 16), ("Heading 3", 13)]:
+                if level in doc.styles:
+                    hs = doc.styles[level]
+                    hs.font.name = font
+                    hs.font.size = Pt(size)
+                    hs.font.color.rgb = RGBColor(0x1a, 0x36, 0x5d)
+
+            for block in blocks:
+                if not isinstance(block, dict):
+                    continue
+                bt = block.get("type", "body")
+
+                if bt in ("h1", "h2", "h3"):
+                    heading_map = {"h1": 0, "h2": 1, "h3": 2}
+                    doc.add_heading(block.get("text", ""), level=heading_map[bt] + 1)
+                elif bt == "body":
+                    p = doc.add_paragraph(block.get("text", ""))
+                    p.paragraph_format.first_line_indent = Cm(0.74)
+                    p.paragraph_format.line_spacing = 1.5
+                elif bt == "bullet":
+                    for item in block.get("items", []):
+                        doc.add_paragraph(item, style="List Bullet")
+                elif bt == "numbered":
+                    for item in block.get("items", []):
+                        doc.add_paragraph(item, style="List Number")
+                elif bt == "table":
+                    headers = block.get("headers", [])
+                    rows = block.get("rows", [])
+                    if headers:
+                        table = doc.add_table(rows=1 + len(rows), cols=len(headers))
+                        table.style = "Light Grid Accent 1"
+                        table.alignment = WD_TABLE_ALIGNMENT.CENTER
+                        for j, h in enumerate(headers):
+                            cell = table.rows[0].cells[j]
+                            cell.text = str(h)
+                            for run in cell.paragraphs[0].runs:
+                                run.bold = True
+                        for i, row in enumerate(rows):
+                            for j, val in enumerate(row):
+                                if j < len(table.columns):
+                                    table.rows[i + 1].cells[j].text = str(val)
+                elif bt == "image":
+                    img_path = block.get("path", "")
+                    img_w = block.get("width", 0)
+                    if img_path and os.path.isfile(img_path):
+                        try:
+                            if img_w > 0:
+                                doc.add_picture(img_path, width=Emu(int(img_w)))
+                            else:
+                                doc.add_picture(img_path, width=Inches(5.5))
+                        except Exception as e:
+                            doc.add_paragraph(f"[图片加载失败: {e}]")
+                elif bt == "pagebreak":
+                    doc.add_page_break()
+                elif bt == "spacer":
+                    doc.add_paragraph("")
+
+            doc.save(str(out))
+            return SkillResult(
+                success=True,
+                message=f"Word 文档已生成: {out}",
+                files=[str(out)],
+                data={"path": str(out), "blocks": len(blocks)},
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"DOCX 生成失败: {e}")
+
+
+class DOCXReadSkill(Skill):
+    """读取 Word 文档内容"""
+    name = "docx_read"
+    description = "读取 Word (DOCX) 文件，提取文本内容。支持提取表格数据。"
+    category = "doc"
+    parameters = [
+        SkillParameter("path", "string", "DOCX 文件路径", required=True),
+        SkillParameter("max_chars", "integer", "最大字符数", required=False, default=50000),
+    ]
+
+    async def execute(self, path: str = "", max_chars: int = 50000, **kwargs) -> SkillResult:
+        try:
+            from docx import Document
+        except ImportError:
+            return SkillResult(success=False, error="python-docx 未安装: pip install python-docx")
+
+        fp = Path(path).expanduser().resolve()
+        if not fp.exists():
+            return SkillResult(success=False, error=f"文件不存在: {path}")
+
+        try:
+            doc = Document(str(fp))
+            parts = []
+            for para in doc.paragraphs:
+                style_name = para.style.name if para.style else ""
+                prefix = ""
+                if "Heading" in style_name:
+                    level = style_name.replace("Heading", "").strip()
+                    prefix = f"[{'#' * int(level) if level.isdigit() else '#'}] "
+                elif "Bullet" in style_name:
+                    prefix = "  * "
+                elif "Number" in style_name or "List" in style_name:
+                    prefix = "  - "
+                text = para.text.strip()
+                if text:
+                    parts.append(f"{prefix}{text}")
+
+            for i, table in enumerate(doc.tables):
+                rows = []
+                for row in table.rows:
+                    cells = [cell.text.strip() for cell in row.cells]
+                    rows.append(" | ".join(cells))
+                if rows:
+                    parts.append(f"\n[表格 {i+1}]")
+                    parts.append(rows[0])
+                    if len(rows) > 1:
+                        parts.append("-" * len(rows[0]))
+                        parts.extend(rows[1:])
+
+            full = "\n".join(parts)
+            if len(full) > max_chars:
+                full = full[:max_chars] + f"\n\n... (截断，共 {len(full)} 字符)"
+
+            return SkillResult(
+                success=True,
+                message=f"已读取 Word 文档: {fp.name}",
+                data={"path": str(fp), "paragraphs": len(doc.paragraphs),
+                      "tables": len(doc.tables)},
+                output=full,
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"DOCX 读取失败: {e}")

package/skills/pdf_skill.py

@@ -0,0 +1,356 @@
+"""
+skills/pdf_skill.py - PDF 文档生成技能
+========================================
+基于 ReportLab 生成专业 PDF 文档，融入 MiniMax PDF Skill 设计理念。
+支持封面、多级标题、段落、列表、表格、图片、分页等。
+"""
+from __future__ import annotations
+
+import json
+import os
+import textwrap
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from skills.base import Skill, SkillParameter, SkillResult
+
+# ── 调色板 (源自 MiniMax PDF Skill design system) ──
+PALETTES = {
+    "report":     {"primary": "#1a365d", "secondary": "#2b6cb0", "accent": "#e53e3e",
+                   "bg": "#ffffff", "text": "#1a202c", "muted": "#718096"},
+    "proposal":   {"primary": "#22543d", "secondary": "#38a169", "accent": "#d69e2e",
+                   "bg": "#ffffff", "text": "#1a202c", "muted": "#718096"},
+    "academic":   {"primary": "#553c9a", "secondary": "#805ad5", "accent": "#e53e3e",
+                   "bg": "#ffffff", "text": "#1a202c", "muted": "#718096"},
+    "minimal":    {"primary": "#2d3748", "secondary": "#4a5568", "accent": "#3182ce",
+                   "bg": "#ffffff", "text": "#1a202c", "muted": "#718096"},
+    "dark":       {"primary": "#e2e8f0", "secondary": "#a0aec0", "accent": "#63b3ed",
+                   "bg": "#1a202c", "text": "#e2e8f0", "muted": "#a0aec0"},
+    "warm":       {"primary": "#744210", "secondary": "#c05621", "accent": "#d69e2e",
+                   "bg": "#fffff0", "text": "#1a202c", "muted": "#718096"},
+}
+
+
+def _hex_to_rgb(h: str) -> tuple:
+    h = h.lstrip("#")
+    return tuple(int(h[i:i+2], 16) / 255.0 for i in (0, 2, 4))
+
+
+class PDFCreateSkill(Skill):
+    """生成 PDF 文档 — 支持封面、标题、段落、列表、表格、图片
+
+    content 为 JSON 数组，每个元素代表一个内容块:
+    - {"type": "h1", "text": "标题"}        — 一级标题
+    - {"type": "h2", "text": "标题"}        — 二级标题
+    - {"type": "h3", "text": "标题"}        — 三级标题
+    - {"type": "body", "text": "正文"}      — 正文段落
+    - {"type": "bullet", "items": ["a","b"]} — 无序列表
+    - {"type": "numbered", "items": ["a","b"]} — 有序列表
+    - {"type": "table", "headers": ["A","B"], "rows": [["1","2"]]}  — 表格
+    - {"type": "image", "path": "/path/to/img.png", "width": 400}  — 图片
+    - {"type": "divider"}                   — 分割线
+    - {"type": "pagebreak"}                 — 分页
+    - {"type": "spacer", "height": 20}     — 空白
+    - {"type": "callout", "text": "提示", "style": "info"} — 提示框
+    """
+    name = "pdf_create"
+    description = (
+        "生成 PDF 文档。支持封面、多级标题、段落、列表、表格、图片、提示框等。"
+        "content 为 JSON 数组，每项: {type, text/items/headers/rows/path...}。"
+        "type 可选: h1/h2/h3/body/bullet/numbered/table/image/divider/pagebreak/spacer/callout。"
+        "palette 可选: report/proposal/academic/minimal/dark/warm。"
+    )
+    category = "pdf"
+    dangerous = True
+    parameters = [
+        SkillParameter("content", "string",
+            "PDF 内容块 JSON 数组，每项含 type 字段。示例: [{\"type\":\"h1\",\"text\":\"报告标题\"},{\"type\":\"body\",\"text\":\"正文内容\"}]",
+            required=True),
+        SkillParameter("output_path", "string",
+            "输出 PDF 文件路径 (如 /tmp/report.pdf)", required=True),
+        SkillParameter("title", "string", "文档标题 (用于封面)", required=False, default=""),
+        SkillParameter("subtitle", "string", "副标题 (用于封面)", required=False, default=""),
+        SkillParameter("author", "string", "作者", required=False, default=""),
+        SkillParameter("palette", "string", "配色方案", required=False,
+                       default="report", enum=["report","proposal","academic","minimal","dark","warm"]),
+        SkillParameter("cover", "boolean", "是否生成封面", required=False, default=True),
+        SkillParameter("page_size", "string", "页面尺寸", required=False,
+                       default="A4", enum=["A4","Letter"]),
+    ]
+
+    async def execute(self, content: str = "", output_path: str = "",
+                      title: str = "", subtitle: str = "", author: str = "",
+                      palette: str = "report", cover: bool = True,
+                      page_size: str = "A4", **kwargs) -> SkillResult:
+        try:
+            from reportlab.lib.pagesizes import A4, letter
+            from reportlab.lib.units import mm, cm
+            from reportlab.lib.colors import HexColor
+            from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+            from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_JUSTIFY
+            from reportlab.platypus import (SimpleDocTemplate, Paragraph, Spacer,
+                Table, TableStyle, Image as RLImage, PageBreak, HRFlowable, KeepTogether)
+            from reportlab.pdfbase import pdfmetrics
+            from reportlab.pdfbase.ttfonts import TTFont
+        except ImportError:
+            return SkillResult(success=False, error="ReportLab 未安装，请运行: pip install reportlab")
+
+        # 解析 content
+        try:
+            blocks = json.loads(content) if isinstance(content, str) else content
+            if not isinstance(blocks, list):
+                blocks = [{"type": "body", "text": str(blocks)}]
+        except json.JSONDecodeError as e:
+            return SkillResult(success=False, error=f"content JSON 解析失败: {e}")
+
+        try:
+            # 输出路径
+            out = Path(output_path).expanduser().resolve()
+            out.parent.mkdir(parents=True, exist_ok=True)
+
+            # 配色
+            pal = PALETTES.get(palette, PALETTES["report"])
+
+            # 页面尺寸
+            ps = A4 if page_size.upper() == "A4" else letter
+            pw, ph = ps
+
+            # 注册中文字体
+            _zh_fonts = {}
+            for _fpath, _fname in [
+                ("/usr/share/fonts/truetype/chinese/SimHei.ttf", "SimHei"),
+                ("/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc", "WQYZenHei"),
+                ("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", "DejaVuSans"),
+            ]:
+                if os.path.isfile(_fpath):
+                    try:
+                        pdfmetrics.registerFont(TTFont(_fname, _fpath))
+                        _zh_fonts[_fname] = _fpath
+                    except Exception:
+                        pass
+
+            font_name = "SimHei" if "SimHei" in _zh_fonts else (
+                "WQYZenHei" if "WQYZenHei" in _zh_fonts else "Helvetica")
+
+            # 样式
+            styles = getSampleStyleSheet()
+            primary_rgb = _hex_to_rgb(pal["primary"])
+            secondary_rgb = _hex_to_rgb(pal["secondary"])
+            accent_rgb = _hex_to_rgb(pal["accent"])
+            text_rgb = _hex_to_rgb(pal["text"])
+            muted_rgb = _hex_to_rgb(pal["muted"])
+
+            styles.add(ParagraphStyle(
+                "zh_h1", fontName=font_name, fontSize=22, leading=28,
+                textColor=HexColor(pal["primary"]), spaceAfter=12, spaceBefore=20))
+            styles.add(ParagraphStyle(
+                "zh_h2", fontName=font_name, fontSize=16, leading=22,
+                textColor=HexColor(pal["primary"]), spaceAfter=8, spaceBefore=16))
+            styles.add(ParagraphStyle(
+                "zh_h3", fontName=font_name, fontSize=13, leading=18,
+                textColor=HexColor(pal["secondary"]), spaceAfter=6, spaceBefore=12))
+            styles.add(ParagraphStyle(
+                "zh_body", fontName=font_name, fontSize=10.5, leading=17,
+                textColor=HexColor(pal["text"]), alignment=TA_JUSTIFY,
+                spaceAfter=6, firstLineIndent=21))
+            styles.add(ParagraphStyle(
+                "zh_bullet", fontName=font_name, fontSize=10.5, leading=17,
+                textColor=HexColor(pal["text"]), leftIndent=20, bulletIndent=8,
+                spaceAfter=3))
+            styles.add(ParagraphStyle(
+                "zh_numbered", fontName=font_name, fontSize=10.5, leading=17,
+                textColor=HexColor(pal["text"]), leftIndent=20, bulletIndent=8,
+                spaceAfter=3))
+            styles.add(ParagraphStyle(
+                "zh_table_header", fontName=font_name, fontSize=10,
+                textColor=HexColor("#ffffff"), alignment=TA_CENTER))
+            styles.add(ParagraphStyle(
+                "zh_table_cell", fontName=font_name, fontSize=9.5,
+                textColor=HexColor(pal["text"]), alignment=TA_LEFT))
+            styles.add(ParagraphStyle(
+                "zh_callout", fontName=font_name, fontSize=10, leading=16,
+                textColor=HexColor(pal["text"]), leftIndent=12, rightIndent=12,
+                spaceBefore=8, spaceAfter=8, backColor=HexColor("#ebf8ff"),
+                borderColor=HexColor(pal["secondary"]), borderWidth=1,
+                borderPadding=8))
+
+            # 构建文档元素
+            story = []
+
+            # 封面
+            if cover and title:
+                story.append(Spacer(1, ph * 0.3))
+                _accent = HexColor(pal["accent"])
+                story.append(HRFlowable(width="40%", thickness=3, color=_accent,
+                                         spaceAfter=20, spaceBefore=0, hAlign="CENTER"))
+                _t = ParagraphStyle("cover_title", fontName=font_name, fontSize=28,
+                                    leading=36, textColor=HexColor(pal["primary"]),
+                                    alignment=TA_CENTER, spaceAfter=12)
+                story.append(Paragraph(title, _t))
+                if subtitle:
+                    _s = ParagraphStyle("cover_sub", fontName=font_name, fontSize=14,
+                                        leading=20, textColor=HexColor(pal["secondary"]),
+                                        alignment=TA_CENTER, spaceAfter=8)
+                    story.append(Paragraph(subtitle, _s))
+                if author:
+                    _a = ParagraphStyle("cover_author", fontName=font_name, fontSize=11,
+                                        leading=16, textColor=HexColor(pal["muted"]),
+                                        alignment=TA_CENTER, spaceAfter=6)
+                    story.append(Paragraph(author, _a))
+                story.append(HRFlowable(width="40%", thickness=3, color=_accent,
+                                         spaceAfter=0, spaceBefore=20, hAlign="CENTER"))
+                story.append(PageBreak())
+
+            # 内容块
+            for block in blocks:
+                if not isinstance(block, dict):
+                    continue
+                bt = block.get("type", "body")
+
+                if bt == "h1":
+                    story.append(Paragraph(str(block.get("text", "")), styles["zh_h1"]))
+                elif bt == "h2":
+                    story.append(Paragraph(str(block.get("text", "")), styles["zh_h2"]))
+                elif bt == "h3":
+                    story.append(Paragraph(str(block.get("text", "")), styles["zh_h3"]))
+                elif bt == "body":
+                    story.append(Paragraph(str(block.get("text", "")), styles["zh_body"]))
+                elif bt == "bullet":
+                    items = block.get("items", [])
+                    for item in items:
+                        story.append(Paragraph(f"\u2022  {item}", styles["zh_bullet"]))
+                elif bt == "numbered":
+                    items = block.get("items", [])
+                    for i, item in enumerate(items, 1):
+                        story.append(Paragraph(f"{i}.  {item}", styles["zh_numbered"]))
+                elif bt == "table":
+                    headers = block.get("headers", [])
+                    rows = block.get("rows", [])
+                    if headers:
+                        data = []
+                        hdr_row = [Paragraph(str(h), styles["zh_table_header"]) for h in headers]
+                        data.append(hdr_row)
+                        for row in rows:
+                            data.append([Paragraph(str(c), styles["zh_table_cell"]) for c in row])
+                        col_w = (pw - 80) / max(len(headers), 1)
+                        t = Table(data, colWidths=[col_w] * len(headers))
+                        t.setStyle(TableStyle([
+                            ("BACKGROUND", (0, 0), (-1, 0), HexColor(pal["primary"])),
+                            ("TEXTCOLOR", (0, 0), (-1, 0), HexColor("#ffffff")),
+                            ("ALIGN", (0, 0), (-1, 0), "CENTER"),
+                            ("FONTNAME", (0, 0), (-1, 0), font_name),
+                            ("FONTSIZE", (0, 0), (-1, 0), 10),
+                            ("BOTTOMPADDING", (0, 0), (-1, 0), 8),
+                            ("TOPPADDING", (0, 0), (-1, 0), 8),
+                            ("BACKGROUND", (0, 1), (-1, -1), HexColor("#f7fafc")),
+                            ("TEXTCOLOR", (0, 1), (-1, -1), HexColor(pal["text"])),
+                            ("FONTNAME", (0, 1), (-1, -1), font_name),
+                            ("FONTSIZE", (0, 1), (-1, -1), 9.5),
+                            ("ALIGN", (0, 1), (-1, -1), "LEFT"),
+                            ("BOTTOMPADDING", (0, 1), (-1, -1), 6),
+                            ("TOPPADDING", (0, 1), (-1, -1), 6),
+                            ("GRID", (0, 0), (-1, -1), 0.5, HexColor("#cbd5e0")),
+                            ("ROWBACKGROUNDS", (0, 1), (-1, -1),
+                             [HexColor("#ffffff"), HexColor("#f7fafc")]),
+                        ]))
+                        story.append(t)
+                elif bt == "image":
+                    img_path = block.get("path", "")
+                    img_w = block.get("width", pw - 80)
+                    if img_path and os.path.isfile(img_path):
+                        try:
+                            img = RLImage(img_path, width=img_w, height=img_w * 0.75)
+                            img.hAlign = "CENTER"
+                            story.append(img)
+                        except Exception as e:
+                            story.append(Paragraph(f"[图片加载失败: {e}]", styles["zh_body"]))
+                elif bt == "divider":
+                    story.append(HRFlowable(width="100%", thickness=0.5,
+                                             color=HexColor("#cbd5e0"), spaceAfter=8, spaceBefore=8))
+                elif bt == "pagebreak":
+                    story.append(PageBreak())
+                elif bt == "spacer":
+                    story.append(Spacer(1, block.get("height", 20)))
+                elif bt == "callout":
+                    style_map = {"info": "#ebf8ff", "warning": "#fffbeb", "error": "#fff5f5",
+                                 "success": "#f0fff4"}
+                    bg = style_map.get(block.get("style", "info"), "#ebf8ff")
+                    cs = ParagraphStyle("callout_dyn", fontName=font_name, fontSize=10,
+                                        leading=16, textColor=HexColor(pal["text"]),
+                                        leftIndent=12, rightIndent=12,
+                                        spaceBefore=8, spaceAfter=8,
+                                        backColor=HexColor(bg), borderWidth=1,
+                                        borderColor=HexColor(pal["secondary"]),
+                                        borderPadding=8)
+                    story.append(Paragraph(str(block.get("text", "")), cs))
+
+            # 生成 PDF
+            doc = SimpleDocTemplate(str(out), pagesize=ps,
+                                     leftMargin=30, rightMargin=30,
+                                     topMargin=30, bottomMargin=30)
+            doc.build(story)
+
+            return SkillResult(
+                success=True,
+                message=f"PDF 文档已生成: {out}",
+                files=[str(out)],
+                data={"path": str(out), "pages": "?", "blocks": len(blocks)},
+        )
+        except Exception as e:
+            return SkillResult(success=False, error=f"PDF 生成失败: {e}")
+
+
+class PDFReadSkill(Skill):
+    """读取 PDF 文件内容，提取文本"""
+    name = "pdf_read"
+    description = "读取 PDF 文件，提取文本内容。支持提取指定页码范围。"
+    category = "pdf"
+    parameters = [
+        SkillParameter("path", "string", "PDF 文件路径", required=True),
+        SkillParameter("page_start", "integer", "起始页 (从1开始)", required=False, default=1),
+        SkillParameter("page_end", "integer", "结束页 (0=全部)", required=False, default=0),
+        SkillParameter("max_chars", "integer", "最大字符数", required=False, default=50000),
+    ]
+
+    async def execute(self, path: str = "", page_start: int = 1, page_end: int = 0,
+                      max_chars: int = 50000, **kwargs) -> SkillResult:
+        try:
+            import importlib
+            for mod_name in ["pypdf", "PyPDF2"]:
+                try:
+                    mod = importlib.import_module(mod_name)
+                    break
+                except ImportError:
+                    continue
+            else:
+                return SkillResult(success=False, error="需要 pypdf 或 PyPDF2: pip install pypdf")
+
+            fp = Path(path).expanduser().resolve()
+            if not fp.exists():
+                return SkillResult(success=False, error=f"文件不存在: {path}")
+
+            reader = mod.PdfReader(str(fp))
+            total = len(reader.pages)
+            ps = page_start - 1
+            pe = page_end if page_end > 0 else total
+            ps = max(0, min(ps, total - 1))
+            pe = max(ps, min(pe, total))
+
+            texts = []
+            for i in range(ps, pe):
+                page = reader.pages[i]
+                t = page.extract_text() or ""
+                texts.append(f"--- 第 {i+1} 页 ---\n{t}")
+
+            full = "\n\n".join(texts)
+            if len(full) > max_chars:
+                full = full[:max_chars] + f"\n\n... (截断，共 {len(full)} 字符)"
+
+            return SkillResult(
+                success=True,
+                message=f"已读取 PDF: {fp.name} (第{ps+1}-{pe}/{total}页)",
+                data={"path": str(fp), "total_pages": total, "pages_read": pe - ps},
+                output=full,
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"PDF 读取失败: {e}")

package/skills/ppt_skill.py

@@ -0,0 +1,311 @@
+"""
+skills/ppt_skill.py - PPT PowerPoint 演示文稿技能
+===============================================
+基于 python-pptx 生成 PowerPoint 演示文稿，融入 MiniMax PPT Skill 设计理念。
+支持多种幻灯片类型、配色方案、图表等。
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from skills.base import Skill, SkillParameter, SkillResult
+
+# 配色方案 (源自 MiniMax PPT design-system)
+THEMES = {
+    "professional": {"primary": "1A365D", "secondary": "2B6CB0", "accent": "E53E3E",
+                     "light": "EBF8FF", "bg": "FFFFFF", "text": "1A202C", "muted": "718096"},
+    "modern":       {"primary": "553C9A", "secondary": "805AD5", "accent": "ED8936",
+                     "light": "FAF5FF", "bg": "FFFFFF", "text": "1A202C", "muted": "718096"},
+    "nature":       {"primary": "22543D", "secondary": "38A169", "accent": "D69E2E",
+                     "light": "F0FFF4", "bg": "FFFFFF", "text": "1A202C", "muted": "718096"},
+    "warm":         {"primary": "744210", "secondary": "C05621", "accent": "DD6B20",
+                     "light": "FFFFF0", "bg": "FFFFFF", "text": "1A202C", "muted": "718096"},
+    "dark":         {"primary": "E2E8F0", "secondary": "A0AEC0", "accent": "63B3ED",
+                     "light": "2D3748", "bg": "1A202C", "text": "E2E8F0", "muted": "A0AEC0"},
+    "minimal":      {"primary": "2D3748", "secondary": "4A5568", "accent": "3182CE",
+                     "light": "F7FAFC", "bg": "FFFFFF", "text": "1A202C", "muted": "718096"},
+}
+
+
+def _hex_to_rgb(hex_str: str):
+    from pptx.dml.color import RGBColor
+    h = hex_str.lstrip("#")
+    return RGBColor(*[int(h[i:i+2], 16) for i in (0, 2, 4)])
+
+
+class PPTCreateSkill(Skill):
+    """生成 PowerPoint 演示文稿
+
+    slides 为 JSON 数组，每个元素代表一张幻灯片:
+    - {"type": "cover", "title": "...", "subtitle": "...", "author": "..."}
+    - {"type": "toc", "title": "...", "items": ["章节1", "章节2"]}
+    - {"type": "section", "title": "章节标题"}
+    - {"type": "content", "title": "...", "body": ["要点1", "要点2"]}
+    - {"type": "content", "title": "...", "table": {"headers": [], "rows": []}}
+    - {"type": "content", "title": "...", "image": {"path": "...", "caption": "..."}}
+    - {"type": "summary", "title": "...", "points": ["要点1", "要点2"]}
+    """
+    name = "ppt_create"
+    description = (
+        "生成 PowerPoint (PPTX) 演示文稿。支持封面、目录、章节、内容、表格、"
+        "图片、总结等幻灯片类型。"
+        "slides 为 JSON 数组，每项: {type, title, body/items/points...}。"
+        "theme 可选: professional/modern/nature/warm/dark/minimal。"
+    )
+    category = "doc"
+    dangerous = True
+    parameters = [
+        SkillParameter("slides", "string",
+            "幻灯片 JSON 数组。type: cover/toc/section/content/summary", required=True),
+        SkillParameter("output_path", "string", "输出 PPTX 文件路径", required=True),
+        SkillParameter("theme", "string", "配色主题", required=False,
+                       default="professional",
+                       enum=["professional","modern","nature","warm","dark","minimal"]),
+        SkillParameter("font", "string", "中文字体", required=False, default="SimHei"),
+    ]
+
+    async def execute(self, slides: str = "", output_path: str = "",
+                      theme: str = "professional", font: str = "SimHei",
+                      **kwargs) -> SkillResult:
+        try:
+            from pptx import Presentation
+            from pptx.util import Inches, Pt, Emu
+            from pptx.dml.color import RGBColor
+            from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
+            from pptx.enum.shapes import MSO_SHAPE
+        except ImportError:
+            return SkillResult(success=False, error="python-pptx 未安装: pip install python-pptx")
+
+        try:
+            slide_data = json.loads(slides) if isinstance(slides, str) else slides
+            if not isinstance(slide_data, list):
+                slide_data = [{"type": "content", "title": str(slide_data)}]
+        except json.JSONDecodeError as e:
+            return SkillResult(success=False, error=f"slides JSON 解析失败: {e}")
+
+        try:
+            out = Path(output_path).expanduser().resolve()
+            out.parent.mkdir(parents=True, exist_ok=True)
+
+            t = THEMES.get(theme, THEMES["professional"])
+            pr = _hex_to_rgb(t["primary"])
+            sc = _hex_to_rgb(t["secondary"])
+            ac = _hex_to_rgb(t["accent"])
+            tc = _hex_to_rgb(t["text"])
+            mc = _hex_to_rgb(t["muted"])
+            lc = _hex_to_rgb(t["light"])
+
+            prs = Presentation()
+            prs.slide_width = Inches(13.333)
+            prs.slide_height = Inches(7.5)
+            BLANK = 6
+
+            def add_text_box(slide, left, top, width, height, text, font_size=18,
+                             bold=False, color=tc, align=PP_ALIGN.LEFT, font_name=font):
+                txBox = slide.shapes.add_textbox(Inches(left), Inches(top),
+                                                  Inches(width), Inches(height))
+                tf = txBox.text_frame
+                tf.word_wrap = True
+                p = tf.paragraphs[0]
+                p.text = text
+                p.font.size = Pt(font_size)
+                p.font.bold = bold
+                p.font.color.rgb = color
+                p.font.name = font_name
+                p.alignment = align
+                return tf
+
+            def add_shape_bg(slide, color_hex):
+                shape = slide.shapes.add_shape(
+                    MSO_SHAPE.RECTANGLE, Inches(0), Inches(0),
+                    prs.slide_width, prs.slide_height)
+                shape.fill.solid()
+                shape.fill.fore_color.rgb = _hex_to_rgb(color_hex)
+                shape.line.fill.background()
+
+            def add_accent_line(slide, left, top, width, color_hex):
+                shape = slide.shapes.add_shape(
+                    MSO_SHAPE.RECTANGLE, Inches(left), Inches(top),
+                    Inches(width), Inches(0.06))
+                shape.fill.solid()
+                shape.fill.fore_color.rgb = _hex_to_rgb(color_hex)
+                shape.line.fill.background()
+
+            def add_page_number(slide, num, total):
+                add_text_box(slide, 12.2, 7.0, 1, 0.4, f"{num}/{total}",
+                             font_size=10, color=mc, align=PP_ALIGN.RIGHT)
+
+            total_slides = len(slide_data)
+
+            for idx, s in enumerate(slide_data):
+                if not isinstance(s, dict):
+                    continue
+                st = s.get("type", "content")
+                slide = prs.slides.add_slide(prs.slide_layouts[BLANK])
+
+                if st != "cover":
+                    add_page_number(slide, idx + 1, total_slides)
+
+                if st == "cover":
+                    add_shape_bg(slide, t["primary"])
+                    add_accent_line(slide, 2, 3.0, 2, t["accent"])
+                    add_text_box(slide, 2, 3.3, 9, 1.5, s.get("title", ""),
+                                 font_size=40, bold=True, color=RGBColor(255, 255, 255))
+                    if s.get("subtitle"):
+                        add_text_box(slide, 2, 5.0, 9, 0.8, s["subtitle"],
+                                     font_size=18, color=RGBColor(200, 200, 200))
+                    if s.get("author"):
+                        add_text_box(slide, 2, 6.0, 9, 0.6, s["author"],
+                                     font_size=14, color=mc)
+
+                elif st == "toc":
+                    add_text_box(slide, 0.8, 0.5, 8, 0.8, s.get("title", "目录"),
+                                 font_size=28, bold=True, color=pr)
+                    add_accent_line(slide, 0.8, 1.4, 1.5, t["accent"])
+                    for i, item in enumerate(s.get("items", [])):
+                        add_text_box(slide, 1.2, 2.0 + i * 0.7, 8, 0.6,
+                                     f"{i+1}.  {item}", font_size=18, color=tc)
+
+                elif st == "section":
+                    add_shape_bg(slide, t["primary"])
+                    add_text_box(slide, 1, 2.5, 11, 2, s.get("title", ""),
+                                 font_size=36, bold=True, color=RGBColor(255, 255, 255),
+                                 align=PP_ALIGN.CENTER)
+
+                elif st == "content":
+                    # 标题栏
+                    title_shape = slide.shapes.add_shape(
+                        MSO_SHAPE.RECTANGLE, Inches(0), Inches(0),
+                        prs.slide_width, Inches(1.2))
+                    title_shape.fill.solid()
+                    title_shape.fill.fore_color.rgb = pr
+                    title_shape.line.fill.background()
+                    add_text_box(slide, 0.8, 0.2, 11, 0.8, s.get("title", ""),
+                                 font_size=24, bold=True, color=RGBColor(255, 255, 255))
+
+                    body = s.get("body", [])
+                    if body and isinstance(body, list):
+                        for i, item in enumerate(body):
+                            y = 1.6 + i * 0.7
+                            if y > 6.8:
+                                break
+                            add_text_box(slide, 1.0, y, 11, 0.6,
+                                         f"\u25cf  {item}", font_size=16, color=tc)
+
+                    table_data = s.get("table", None)
+                    if table_data and isinstance(table_data, dict):
+                        headers = table_data.get("headers", [])
+                        rows = table_data.get("rows", [])
+                        if headers:
+                            n_rows = len(rows) + 1
+                            n_cols = len(headers)
+                            tbl = slide.shapes.add_table(
+                                n_rows, n_cols, Inches(0.8), Inches(1.6),
+                                Inches(11.7), Inches(min(n_rows * 0.5 + 0.5, 5.0))).table
+                            for j, h in enumerate(headers):
+                                cell = tbl.cell(0, j)
+                                cell.text = str(h)
+                                for p in cell.text_frame.paragraphs:
+                                    p.font.size = Pt(12)
+                                    p.font.bold = True
+                                    p.font.color.rgb = RGBColor(255, 255, 255)
+                                    p.font.name = font
+                                cell.fill.solid()
+                                cell.fill.fore_color.rgb = pr
+                            for i, row in enumerate(rows):
+                                for j, val in enumerate(row):
+                                    if j < n_cols:
+                                        cell = tbl.cell(i + 1, j)
+                                        cell.text = str(val)
+                                        for p in cell.text_frame.paragraphs:
+                                            p.font.size = Pt(11)
+                                            p.font.color.rgb = tc
+                                            p.font.name = font
+                                        if i % 2 == 0:
+                                            cell.fill.solid()
+                                            cell.fill.fore_color.rgb = lc
+
+                    image_data = s.get("image", None)
+                    if image_data and isinstance(image_data, dict):
+                        img_path = image_data.get("path", "")
+                        caption = image_data.get("caption", "")
+                        if img_path and os.path.isfile(img_path):
+                            try:
+                                slide.shapes.add_picture(img_path, Inches(2), Inches(1.8),
+                                                          width=Inches(9))
+                            except Exception:
+                                add_text_box(slide, 2, 3, 9, 1, "[图片加载失败]",
+                                             font_size=14, color=mc, align=PP_ALIGN.CENTER)
+                        if caption:
+                            add_text_box(slide, 2, 6.2, 9, 0.6, caption,
+                                         font_size=12, color=mc, align=PP_ALIGN.CENTER)
+
+                elif st == "summary":
+                    add_text_box(slide, 0.8, 0.5, 11, 0.8, s.get("title", "总结"),
+                                 font_size=28, bold=True, color=pr)
+                    add_accent_line(slide, 0.8, 1.4, 1.5, t["accent"])
+                    for i, pt in enumerate(s.get("points", [])):
+                        y = 2.0 + i * 0.8
+                        if y > 6.5:
+                            break
+                        add_text_box(slide, 1.2, y, 10, 0.6,
+                                     f"\u2713  {pt}", font_size=17, color=tc)
+
+            prs.save(str(out))
+            return SkillResult(
+                success=True,
+                message=f"PPT 已生成: {out} ({total_slides} 张幻灯片)",
+                files=[str(out)],
+                data={"path": str(out), "slides": total_slides, "theme": theme},
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"PPT 生成失败: {e}")
+
+
+class PPTReadSkill(Skill):
+    """读取 PowerPoint 文件内容"""
+    name = "ppt_read"
+    description = "读取 PowerPoint (PPTX) 文件，提取文本内容。"
+    category = "doc"
+    parameters = [
+        SkillParameter("path", "string", "PPTX 文件路径", required=True),
+        SkillParameter("max_chars", "integer", "最大字符数", required=False, default=30000),
+    ]
+
+    async def execute(self, path: str = "", max_chars: int = 30000, **kwargs) -> SkillResult:
+        try:
+            from pptx import Presentation
+        except ImportError:
+            return SkillResult(success=False, error="python-pptx 未安装: pip install python-pptx")
+
+        fp = Path(path).expanduser().resolve()
+        if not fp.exists():
+            return SkillResult(success=False, error=f"文件不存在: {path}")
+
+        try:
+            prs = Presentation(str(fp))
+            parts = []
+            for i, slide in enumerate(prs.slides):
+                slide_texts = []
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text.strip():
+                        slide_texts.append(shape.text.strip())
+                if slide_texts:
+                    parts.append(f"--- 幻灯片 {i+1} ---")
+                    parts.extend(slide_texts)
+
+            full = "\n".join(parts)
+            if len(full) > max_chars:
+                full = full[:max_chars] + "\n..."
+
+            return SkillResult(
+                success=True,
+                message=f"已读取 PPT: {fp.name} ({len(prs.slides)} 张幻灯片)",
+                data={"path": str(fp), "slides": len(prs.slides)},
+                output=full,
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"PPT 读取失败: {e}")

package/skills/xlsx_skill.py

@@ -0,0 +1,303 @@
+"""
+skills/xlsx_skill.py - XLSX Excel 电子表格技能
+=============================================
+基于 openpyxl 创建和编辑 Excel 文件，融入 MiniMax XLSX Skill 设计理念。
+支持创建/编辑/格式化工作表、图表、公式等。
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from skills.base import Skill, SkillParameter, SkillResult
+
+
+class XLSXCreateSkill(Skill):
+    """生成 Excel 电子表格
+
+    sheets 为 JSON 对象，key 为工作表名，value 为:
+    {
+      "headers": ["列1", "列2", ...],
+      "rows": [["值1", "值2"], ...],
+      "col_widths": [15, 20, ...],
+      "freeze_panes": "A2",
+      "auto_filter": true,
+      "formulas": {"C2": "=A2+B2"},
+    }
+    """
+    name = "xlsx_create"
+    description = (
+        "生成 Excel (XLSX) 电子表格。支持多工作表、表头、数据行、公式、"
+        "冻结窗格、自动筛选、列宽设置。"
+        "sheets 为 JSON 对象，key 为工作表名。"
+    )
+    category = "doc"
+    dangerous = True
+    parameters = [
+        SkillParameter("sheets", "string",
+            "工作表数据 JSON 对象。key=工作表名, value={headers, rows, col_widths?, formulas?}。"
+            "示例: {\"Sheet1\":{\"headers\":[\"Name\",\"Score\"],\"rows\":[[\"Alice\",95]]}}",
+            required=True),
+        SkillParameter("output_path", "string", "输出 XLSX 文件路径", required=True),
+        SkillParameter("title", "string", "文档标题", required=False, default=""),
+    ]
+
+    async def execute(self, sheets: str = "", output_path: str = "",
+                      title: str = "", **kwargs) -> SkillResult:
+        try:
+            import openpyxl
+            from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+            from openpyxl.utils import get_column_letter
+        except ImportError:
+            return SkillResult(success=False, error="openpyxl 未安装: pip install openpyxl")
+
+        try:
+            sheets_data = json.loads(sheets) if isinstance(sheets, str) else sheets
+            if not isinstance(sheets_data, dict):
+                return SkillResult(success=False, error="sheets 必须是 JSON 对象 (key=工作表名)")
+        except json.JSONDecodeError as e:
+            return SkillResult(success=False, error=f"sheets JSON 解析失败: {e}")
+
+        try:
+            out = Path(output_path).expanduser().resolve()
+            out.parent.mkdir(parents=True, exist_ok=True)
+
+            wb = openpyxl.Workbook()
+            wb.remove(wb.active)
+
+            header_font = Font(name="SimHei", size=11, bold=True, color="FFFFFF")
+            header_fill = PatternFill(start_color="1A365D", end_color="1A365D", fill_type="solid")
+            header_align = Alignment(horizontal="center", vertical="center", wrap_text=True)
+            cell_font = Font(name="SimHei", size=10)
+            cell_align = Alignment(vertical="center", wrap_text=True)
+            formula_font = Font(name="Consolas", size=10, color="006400")
+            thin_border = Border(
+                left=Side(style="thin", color="D0D5DD"),
+                right=Side(style="thin", color="D0D5DD"),
+                top=Side(style="thin", color="D0D5DD"),
+                bottom=Side(style="thin", color="D0D5DD"),
+            )
+            alt_fill = PatternFill(start_color="F7FAFC", end_color="F7FAFC", fill_type="solid")
+
+            total_rows = 0
+            for sheet_name, sheet_data in sheets_data.items():
+                if not isinstance(sheet_data, dict):
+                    continue
+                ws = wb.create_sheet(title=sheet_name[:31])
+                headers = sheet_data.get("headers", [])
+                rows = sheet_data.get("rows", [])
+                col_widths = sheet_data.get("col_widths", [])
+                formulas = sheet_data.get("formulas", {})
+                freeze_panes = sheet_data.get("freeze_panes", "")
+                auto_filter = sheet_data.get("auto_filter", False)
+
+                for col_idx, header in enumerate(headers, 1):
+                    cell = ws.cell(row=1, column=col_idx, value=header)
+                    cell.font = header_font
+                    cell.fill = header_fill
+                    cell.alignment = header_align
+                    cell.border = thin_border
+
+                for row_idx, row_data in enumerate(rows, 2):
+                    for col_idx, val in enumerate(row_data, 1):
+                        cell = ws.cell(row=row_idx, column=col_idx, value=val)
+                        cell.font = cell_font
+                        cell.alignment = cell_align
+                        cell.border = thin_border
+                        if row_idx % 2 == 0:
+                            cell.fill = alt_fill
+                    total_rows += 1
+
+                for cell_ref, formula in formulas.items():
+                    cell = ws[cell_ref]
+                    cell.value = formula
+                    cell.font = formula_font
+                    cell.border = thin_border
+
+                if not col_widths:
+                    for col_idx in range(1, len(headers) + 1):
+                        max_len = len(str(headers[col_idx - 1])) if col_idx <= len(headers) else 0
+                        for row_data in rows[:50]:
+                            if col_idx <= len(row_data):
+                                max_len = max(max_len, len(str(row_data[col_idx - 1])))
+                        ws.column_dimensions[get_column_letter(col_idx)].width = min(max(max_len + 4, 10), 50)
+                else:
+                    for i, w in enumerate(col_widths, 1):
+                        ws.column_dimensions[get_column_letter(i)].width = w
+
+                if freeze_panes:
+                    ws.freeze_panes = freeze_panes
+                if auto_filter and headers:
+                    ws.auto_filter.ref = f"A1:{get_column_letter(len(headers))}{len(rows) + 1}"
+
+            if title:
+                wb.properties.title = title
+
+            wb.save(str(out))
+            sheet_names = list(sheets_data.keys())
+            return SkillResult(
+                success=True,
+                message=f"Excel 文件已生成: {out} ({len(sheet_names)} 个工作表, {total_rows} 行数据)",
+                files=[str(out)],
+                data={"path": str(out), "sheets": sheet_names, "total_rows": total_rows},
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"XLSX 生成失败: {e}")
+
+
+class XLSXReadSkill(Skill):
+    """读取 Excel 文件内容"""
+    name = "xlsx_read"
+    description = "读取 Excel (XLSX/XLS/CSV) 文件，提取数据。支持指定工作表和行数限制。"
+    category = "doc"
+    parameters = [
+        SkillParameter("path", "string", "Excel 文件路径", required=True),
+        SkillParameter("sheet", "string", "工作表名 (空=第一个)", required=False, default=""),
+        SkillParameter("max_rows", "integer", "最大读取行数", required=False, default=200),
+        SkillParameter("max_chars", "integer", "最大字符数", required=False, default=50000),
+    ]
+
+    async def execute(self, path: str = "", sheet: str = "", max_rows: int = 200,
+                      max_chars: int = 50000, **kwargs) -> SkillResult:
+        try:
+            import openpyxl
+        except ImportError:
+            return SkillResult(success=False, error="openpyxl 未安装: pip install openpyxl")
+
+        fp = Path(path).expanduser().resolve()
+        if not fp.exists():
+            return SkillResult(success=False, error=f"文件不存在: {path}")
+
+        try:
+            wb = openpyxl.load_workbook(str(fp), read_only=True, data_only=True)
+            if not wb.worksheets:
+                wb.close()
+                import csv
+                text = fp.read_text(encoding="utf-8-sig", errors="replace")
+                reader = csv.reader(text.splitlines())
+                rows = list(reader)
+                if len(rows) > max_rows:
+                    rows = rows[:max_rows]
+                full = "\n".join("\t".join(row) for row in rows)
+                if len(full) > max_chars:
+                    full = full[:max_chars] + "\n..."
+                return SkillResult(success=True, message=f"已读取 CSV: {fp.name} ({len(rows)} 行)",
+                                   output=full, data={"rows": len(rows)})
+
+            sheet_names = wb.sheetnames
+            ws_name = sheet if sheet and sheet in sheet_names else sheet_names[0]
+            ws = wb[ws_name]
+
+            parts = []
+            row_count = 0
+            for row in ws.iter_rows(values_only=True):
+                if row_count >= max_rows:
+                    parts.append(f"\n... (仅显示前 {max_rows} 行)")
+                    break
+                cells = [str(c) if c is not None else "" for c in row]
+                parts.append("\t".join(cells))
+                row_count += 1
+
+            wb.close()
+            full = "\n".join(parts)
+            if len(full) > max_chars:
+                full = full[:max_chars] + "\n..."
+
+            return SkillResult(
+                success=True,
+                message=f"已读取 Excel: {fp.name} (工作表: {ws_name}, {row_count} 行)",
+                data={"path": str(fp), "sheets": sheet_names, "active_sheet": ws_name,
+                      "rows": row_count},
+                output=full,
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"XLSX 读取失败: {e}")
+
+
+class XLSXEditSkill(Skill):
+    """编辑 Excel 文件"""
+    name = "xlsx_edit"
+    description = "编辑已有 Excel 文件。支持: append_row, add_column, update_cell。"
+    category = "doc"
+    dangerous = True
+    parameters = [
+        SkillParameter("path", "string", "Excel 文件路径", required=True),
+        SkillParameter("action", "string", "操作类型", required=True,
+                       enum=["append_row", "add_column", "update_cell"]),
+        SkillParameter("sheet", "string", "工作表名 (空=第一个)", required=False, default=""),
+        SkillParameter("data", "string",
+            "操作数据 JSON。"
+            "append_row: [[\"值1\",\"值2\"]]"
+            "add_column: {\"header\":\"列名\", \"values\":[1,2,3]}"
+            "update_cell: {\"cell\":\"A1\", \"value\":\"新值\"}",
+            required=True),
+    ]
+
+    async def execute(self, path: str = "", action: str = "", sheet: str = "",
+                      data: str = "", **kwargs) -> SkillResult:
+        try:
+            import openpyxl
+            from openpyxl.styles import Font, PatternFill
+            from openpyxl.utils import get_column_letter
+        except ImportError:
+            return SkillResult(success=False, error="openpyxl 未安装")
+
+        fp = Path(path).expanduser().resolve()
+        if not fp.exists():
+            return SkillResult(success=False, error=f"文件不存在: {path}")
+
+        try:
+            data_parsed = json.loads(data) if isinstance(data, str) else data
+        except json.JSONDecodeError as e:
+            return SkillResult(success=False, error=f"data JSON 解析失败: {e}")
+
+        try:
+            wb = openpyxl.load_workbook(str(fp))
+            ws_name = sheet if sheet and sheet in wb.sheetnames else wb.sheetnames[0]
+            ws = wb[ws_name]
+
+            if action == "append_row":
+                last_row = ws.max_row
+                rows_to_add = data_parsed if isinstance(data_parsed[0], list) else [data_parsed]
+                for row_data in rows_to_add:
+                    last_row += 1
+                    for col_idx, val in enumerate(row_data, 1):
+                        ws.cell(row=last_row, column=col_idx, value=val)
+                msg = f"追加 {len(rows_to_add)} 行到工作表 '{ws_name}'"
+
+            elif action == "add_column":
+                header = data_parsed.get("header", "New Column")
+                values = data_parsed.get("values", [])
+                formula = data_parsed.get("formula", "")
+                new_col = ws.max_column + 1
+                ws.cell(row=1, column=new_col, value=header)
+                ws.cell(row=1, column=new_col).font = Font(bold=True, color="FFFFFF")
+                ws.cell(row=1, column=new_col).fill = PatternFill(start_color="1A365D", fill_type="solid")
+                if formula:
+                    for i in range(2, ws.max_row + 1):
+                        cell = ws.cell(row=i, column=new_col)
+                        cell.value = formula.replace("{ROW}", str(i))
+                        cell.font = Font(name="Consolas", color="006400")
+                elif values:
+                    for i, val in enumerate(values):
+                        ws.cell(row=i + 2, column=new_col, value=val)
+                msg = f"添加列 '{header}' 到工作表 '{ws_name}'"
+
+            elif action == "update_cell":
+                cell_ref = data_parsed.get("cell", "A1")
+                value = data_parsed.get("value", "")
+                ws[cell_ref] = value
+                msg = f"更新单元格 {cell_ref} = {value}"
+            else:
+                return SkillResult(success=False, error=f"未知操作: {action}")
+
+            wb.save(str(fp))
+            return SkillResult(
+                success=True, message=f"编辑成功: {msg}",
+                files=[str(fp)],
+                data={"path": str(fp), "action": action, "sheet": ws_name},
+            )
+        except Exception as e:
+            return SkillResult(success=False, error=f"XLSX 编辑失败: {e}")