workflow-cli 0.1.0__py3-none-any.whl

wfcli/core/docgen.py

@@ -0,0 +1,219 @@
+"""文档生成引擎
+
+基于模板结构生成交互式文档，收集用户输入后填充模板。
+"""
+
+from pathlib import Path
+from datetime import datetime
+from typing import Any
+
+import click
+
+from wfcli.core.template import load_template, list_templates
+from wfcli.core.naming import build_filename, check_duplicate
+from wfcli.utils.fs import read_template
+
+
+def select_template(workspace_root: Path) -> dict:
+    """交互式选择模板
+
+    Returns:
+        选中的模板信息 {"name", "path", "type"}
+    """
+    templates = list_templates(workspace_root)
+    if not templates:
+        raise click.ClickException("当前工作空间没有可用模板，请先检查工作空间是否完整。")
+
+    click.echo("\n可用文档类型：")
+    for i, t in enumerate(templates, 1):
+        click.echo(f"  [{i}] {t['type']}  ({t['name']})")
+
+    choice = click.prompt(
+        "\n请选择文档类型",
+        type=click.IntRange(1, len(templates)),
+    )
+    return templates[choice - 1]
+
+
+def collect_inputs(template_data: dict) -> dict[str, str]:
+    """根据模板的 AI 执行指令，交互式收集用户输入
+
+    Args:
+        template_data: load_template() 的返回值
+
+    Returns:
+        {指令描述: 用户输入} 的字典
+    """
+    instructions = template_data.get("instructions", [])
+    if not instructions:
+        return {}
+
+    click.echo("\n请按提示填写文档内容：")
+    click.echo("─" * 40)
+
+    inputs = {}
+    for i, instruction in enumerate(instructions, 1):
+        # 将指令转为简短的提示
+        prompt_text = instruction[:80] + "..." if len(instruction) > 80 else instruction
+        value = click.prompt(f"\n[{i}] {prompt_text}", default="", show_default=False)
+        inputs[instruction] = value
+
+    return inputs
+
+
+def generate_document(
+    template_data: dict,
+    inputs: dict[str, str],
+    title: str = "",
+    date: datetime | None = None,
+) -> str:
+    """根据模板和用户输入生成文档内容
+
+    Args:
+        template_data: load_template() 的返回值
+        inputs: collect_inputs() 的返回值
+        title: 文档标题
+        date: 文档日期
+
+    Returns:
+        生成的 Markdown 文档内容
+    """
+    date = date or datetime.now()
+    date_str = date.strftime("%Y-%m-%d")
+
+    lines = []
+
+    # 文档标题
+    if title:
+        lines.append(f"# {title}\n")
+
+    # 元信息
+    lines.append(f"> 生成日期：{date_str}")
+    lines.append(f"> 模板：{template_data.get('name', '')}\n")
+
+    # 按模板骨架生成内容
+    sections = template_data.get("sections", {})
+    structure = template_data.get("structure", [])
+
+    for heading in structure:
+        level = len(heading) - len(heading.lstrip("#"))
+        heading_text = heading.lstrip("# ").strip()
+
+        if level == 1:
+            continue  # 跳过一级标题（已添加）
+
+        lines.append(f"\n{heading}")
+
+        # 如果该章节有用户输入，填充输入内容
+        section_content = sections.get(heading_text, "")
+        matched_input = _find_matching_input(heading_text, inputs)
+
+        if matched_input:
+            lines.append(f"\n{matched_input}")
+        elif section_content:
+            # 保留模板中的指导性内容（去掉占位符）
+            cleaned = _clean_placeholder(section_content)
+            if cleaned:
+                lines.append(f"\n{cleaned}")
+
+    return "\n".join(lines)
+
+
+def save_document(
+    content: str,
+    workspace_root: Path,
+    target_dir: str,
+    filename: str,
+) -> Path:
+    """保存生成的文档到本地目录
+
+    Args:
+        content: 文档内容
+        workspace_root: 工作空间根目录
+        target_dir: 目标目录名（相对于工作空间根目录）
+        filename: 文件名
+
+    Returns:
+        保存的文件路径
+    """
+    target_path = workspace_root / target_dir
+    target_path.mkdir(parents=True, exist_ok=True)
+
+    file_path = target_path / filename
+    file_path.write_text(content, encoding="utf-8")
+    return file_path
+
+
+def check_and_save(
+    content: str,
+    workspace_root: Path,
+    target_dir: str,
+    topic: str,
+    ext: str = "md",
+) -> Path:
+    """检查重复并保存文档
+
+    如果存在疑似重复文件，提示用户选择覆盖或新建。
+    """
+    target_path = workspace_root / target_dir
+    duplicates = check_duplicate(target_path, topic, ext)
+
+    if duplicates:
+        click.echo(f"\n发现疑似重复文件：")
+        for i, f in enumerate(duplicates, 1):
+            click.echo(f"  [{i}] {f.name}")
+        click.echo(f"  [0] 新建文件")
+
+        choice = click.prompt("请选择处理方式", type=click.IntRange(0, len(duplicates)), default=0)
+
+        if choice > 0:
+            # 覆盖已有文件
+            existing = duplicates[choice - 1]
+            existing.write_text(content, encoding="utf-8")
+            return existing
+
+    # 新建文件
+    filename = build_filename(topic, ext)
+    return save_document(content, workspace_root, target_dir, filename)
+
+
+def run_checklist(template_data: dict) -> bool:
+    """运行自检清单，返回是否全部通过"""
+    checklist = template_data.get("checklist", [])
+    if not checklist:
+        return True
+
+    click.echo("\n自检清单：")
+    all_passed = True
+    for item in checklist:
+        result = click.confirm(f"  [ ] {item}", default=True)
+        if not result:
+            all_passed = False
+
+    return all_passed
+
+
+# ── 内部工具函数 ──────────────────────────────────────────────────
+
+def _find_matching_input(heading: str, inputs: dict) -> str:
+    """根据标题找到对应的用户输入"""
+    heading_lower = heading.lower()
+    for instruction, value in inputs.items():
+        instr_lower = instruction.lower()
+        if heading_lower in instr_lower or instr_lower in heading_lower:
+            return value
+    return ""
+
+
+def _clean_placeholder(content: str) -> str:
+    """清理模板中的占位符内容"""
+    lines = []
+    for line in content.split("\n"):
+        stripped = line.strip()
+        # 跳过明显的占位符
+        if stripped in ("...", "[待填写]", "[占位]", "TODO"):
+            continue
+        if stripped.startswith("<!--") and stripped.endswith("-->"):
+            continue
+        lines.append(line)
+    return "\n".join(lines).strip()

wfcli/core/naming.py

@@ -0,0 +1,125 @@
+"""文件命名规范工具
+
+命名格式: {日期}_{主题描述}.{扩展名}
+日期格式: YYYY-MM-DD
+示例: 2026-06-24_季度经营分析会.md
+"""
+
+import re
+from datetime import datetime
+from pathlib import Path
+
+
+# 标准日期格式
+DATE_FORMAT = "%Y-%m-%d"
+DATE_PATTERN = re.compile(r"^\d{4}-\d{2}-\d{2}_")
+
+
+def build_filename(
+    topic: str,
+    ext: str = "md",
+    date: datetime | None = None,
+) -> str:
+    """生成标准文件名
+
+    Args:
+        topic: 主题描述
+        ext: 文件扩展名，默认 md
+        date: 日期，默认为今天
+
+    Returns:
+        格式化的文件名，如 "2026-06-24_季度经营分析会.md"
+    """
+    date = date or datetime.now()
+    date_str = date.strftime(DATE_FORMAT)
+    # 清理主题中的非法字符
+    topic = re.sub(r'[\\/:*?"<>|]', "_", topic).strip()
+    return f"{date_str}_{topic}.{ext}"
+
+
+def parse_filename(filename: str) -> dict:
+    """解析文件名，提取日期和主题
+
+    Returns:
+        {"date": str, "topic": str, "ext": str, "valid": bool}
+    """
+    path = Path(filename)
+    name = path.stem
+    ext = path.suffix.lstrip(".")
+
+    result = {"date": "", "topic": name, "ext": ext, "valid": False}
+
+    if DATE_PATTERN.match(name):
+        date_str = name[:10]
+        topic = name[11:]  # 跳过日期和下划线
+        result["date"] = date_str
+        result["topic"] = topic
+        result["valid"] = True
+    else:
+        result["topic"] = name
+
+    return result
+
+
+def validate_filename(filename: str) -> tuple[bool, str]:
+    """校验文件名是否符合命名规范
+
+    Returns:
+        (是否合规, 不合规原因)
+    """
+    info = parse_filename(filename)
+    if not info["valid"]:
+        return False, f"文件名不符合规范（应为 YYYY-MM-DD_主题.扩展名）: {filename}"
+
+    # 校验日期是否合法
+    try:
+        datetime.strptime(info["date"], DATE_FORMAT)
+    except ValueError:
+        return False, f"日期不合法: {info['date']}"
+
+    # 校验主题是否为空
+    if not info["topic"].strip():
+        return False, "主题描述不能为空"
+
+    return True, ""
+
+
+def check_duplicate(directory: Path, topic: str, ext: str = "md") -> list[Path]:
+    """检查目录下是否存在主题相近的文件
+
+    Args:
+        directory: 目标目录
+        topic: 主题关键词
+        ext: 扩展名
+
+    Returns:
+        疑似重复的文件列表
+    """
+    if not directory.exists():
+        return []
+
+    duplicates = []
+    topic_lower = topic.lower()
+    for f in directory.glob(f"*.{ext}"):
+        info = parse_filename(f.name)
+        if topic_lower in info["topic"].lower():
+            duplicates.append(f)
+
+    return sorted(duplicates, key=lambda p: p.name, reverse=True)
+
+
+def get_week_number(date: datetime | None = None) -> int:
+    """获取 ISO 周数"""
+    date = date or datetime.now()
+    return date.isocalendar()[1]
+
+
+def get_week_filename(topic: str = "工作总结", ext: str = "md", date: datetime | None = None) -> str:
+    """生成周报标准文件名
+
+    格式: YYYY-MM-DD_第XX周{topic}.ext
+    """
+    date = date or datetime.now()
+    week_num = get_week_number(date)
+    full_topic = f"第{week_num}周{topic}"
+    return build_filename(full_topic, ext, date)

wfcli/core/template.py

@@ -0,0 +1,154 @@
+"""模板读取与解析"""
+
+import re
+from pathlib import Path
+from typing import Any
+
+
+def load_template(template_path: Path) -> dict[str, Any]:
+    """加载并解析模板文件
+
+    Args:
+        template_path: 模板文件路径
+
+    Returns:
+        {
+            "raw_content": str,        # 模板原文
+            "structure": list[str],    # 文档骨架（标题层级）
+            "instructions": list[str], # AI 执行指令
+            "checklist": list[str],    # 自检清单
+            "sections": dict,          # 按章节拆分的内容
+        }
+    """
+    content = template_path.read_text(encoding="utf-8")
+
+    return {
+        "raw_content": content,
+        "structure": _extract_structure(content),
+        "instructions": _extract_instructions(content),
+        "checklist": _extract_checklist(content),
+        "sections": _split_sections(content),
+        "path": str(template_path),
+        "name": template_path.stem,
+    }
+
+
+def _extract_structure(content: str) -> list[str]:
+    """提取文档骨架（所有标题行）"""
+    structure = []
+    for line in content.split("\n"):
+        if line.startswith("#"):
+            structure.append(line.strip())
+    return structure
+
+
+def _extract_instructions(content: str) -> list[str]:
+    """提取 AI 执行指令
+
+    通常在模板中以特定标记识别，如:
+    - "## AI 执行指令" 下的列表项
+    - 以 "- [ ]" 开头的待办项
+    - 包含"请"、"需要"等指令词的句子
+    """
+    instructions = []
+    in_instruction_section = False
+
+    for line in content.split("\n"):
+        stripped = line.strip()
+
+        # 检测指令章节
+        if re.match(r"^#+\s*(AI|执行|指令|填写|要求)", stripped, re.IGNORECASE):
+            in_instruction_section = True
+            continue
+        elif stripped.startswith("#") and in_instruction_section:
+            in_instruction_section = False
+            continue
+
+        if in_instruction_section:
+            if stripped.startswith("- ") or stripped.startswith("* "):
+                instructions.append(stripped[2:].strip())
+            elif stripped and not stripped.startswith("#"):
+                instructions.append(stripped)
+
+    return instructions
+
+
+def _extract_checklist(content: str) -> list[str]:
+    """提取自检清单
+
+    通常在 "## 自检清单" 章节，以 "- [ ]" 开头的条目
+    """
+    checklist = []
+    in_checklist_section = False
+
+    for line in content.split("\n"):
+        stripped = line.strip()
+
+        if re.match(r"^#+\s*(自检|检查|验证|checklist)", stripped, re.IGNORECASE):
+            in_checklist_section = True
+            continue
+        elif stripped.startswith("#") and in_checklist_section:
+            in_checklist_section = False
+            continue
+
+        if in_checklist_section:
+            if stripped.startswith("- [ ]") or stripped.startswith("- [x]"):
+                checklist.append(stripped[6:].strip())
+            elif stripped.startswith("- "):
+                checklist.append(stripped[2:].strip())
+
+    return checklist
+
+
+def _split_sections(content: str) -> dict[str, str]:
+    """按二级标题拆分内容"""
+    sections = {}
+    current_key = ""
+    current_lines = []
+
+    for line in content.split("\n"):
+        if line.startswith("## "):
+            if current_key:
+                sections[current_key] = "\n".join(current_lines).strip()
+            current_key = line[3:].strip()
+            current_lines = []
+        else:
+            current_lines.append(line)
+
+    if current_key:
+        sections[current_key] = "\n".join(current_lines).strip()
+
+    return sections
+
+
+def list_templates(workspace_root: Path) -> list[dict]:
+    """列出工作空间中所有可用模板
+
+    Returns:
+        [{"name": str, "path": Path, "type": str}, ...]
+    """
+    templates_dir = workspace_root / "00_模板"
+    if not templates_dir.exists():
+        return []
+
+    templates = []
+    for f in sorted(templates_dir.glob("*.md")):
+        # 从文件名推断文档类型
+        # 格式: {编号}_{编号}_{名称}模板.md
+        name = f.stem
+        doc_type = name
+        # 去掉 "模板" 后缀
+        if name.endswith("模板"):
+            doc_type = name[:-2]
+        # 去掉编号前缀
+        parts = doc_type.split("_")
+        if len(parts) > 2 and parts[0].isdigit():
+            doc_type = "_".join(parts[2:]) if len(parts) > 2 else parts[-1]
+
+        templates.append({
+            "name": name,
+            "path": f,
+            "type": doc_type,
+        })
+
+    return templates

wfcli/core/workspace.py

@@ -0,0 +1,140 @@
+"""工作空间业务逻辑 - 目录结构解析与校验"""
+
+from pathlib import Path
+from typing import Any
+
+from wfcli.lark import LarkClient, LarkError
+from wfcli import config as cfg
+from wfcli.utils.fs import parse_workspace_md, ensure_dir
+
+
+def list_workspaces(client: LarkClient | None = None) -> list[dict]:
+    """列出云盘上所有工作空间（一级文件夹）
+
+    Returns:
+        工作空间列表，每项含 name, token
+    """
+    client = client or LarkClient()
+    root_token = cfg.get("feishu.root_folder_token")
+    if not root_token:
+        raise LarkError("未配置 feishu.root_folder_token，请运行: wfcli config set feishu.root_folder_token <token>")
+
+    files = client.drive_list_files(root_token)
+    return [
+        {"name": f["name"], "token": f.get("token", ""), "type": f.get("type", "")}
+        for f in files
+        if f.get("type") == "folder"
+    ]
+
+
+def check_workspace_exists(name: str, client: LarkClient | None = None) -> dict | None:
+    """检查云盘上是否已存在同名工作空间
+
+    Returns:
+        已存在则返回 {"name": ..., "token": ...}，否则 None
+    """
+    workspaces = list_workspaces(client)
+    for ws in workspaces:
+        if ws["name"] == name:
+            return ws
+    return None
+
+
+def download_workspace(
+    workspace_token: str,
+    local_dir: Path,
+    client: LarkClient | None = None,
+) -> Path:
+    """下载工作空间到本地
+
+    Args:
+        workspace_token: 工作空间文件夹 token
+        local_dir: 本地目标目录
+        client: LarkClient 实例
+
+    Returns:
+        本地工作空间根目录
+    """
+    client = client or LarkClient()
+    ensure_dir(local_dir)
+
+    # 1. 获取工作空间根目录文件列表
+    files = client.drive_list_files(workspace_token)
+
+    # 2. 下载 WORKSPACE.md
+    ws_file = next((f for f in files if f.get("name") == "WORKSPACE.md"), None)
+    if not ws_file:
+        raise LarkError("工作空间中未找到 WORKSPACE.md")
+
+    ws_token = ws_file.get("token", "")
+    client.drive_download(ws_token, local_dir)
+
+    # 3. 解析 WORKSPACE.md 获取目录结构
+    ws_md_path = local_dir / "WORKSPACE.md"
+    ws_info = parse_workspace_md(ws_md_path)
+
+    # 4. 创建本地子目录
+    for d in ws_info.get("directories", []):
+        dir_name = d["name"]
+        ensure_dir(local_dir / dir_name)
+
+    # 5. 下载模板文件
+    templates_dir = next(
+        (f for f in files if f.get("name", "").startswith("00_")),
+        None
+    )
+    if templates_dir:
+        template_token = templates_dir.get("token", "")
+        template_files = client.drive_list_files(template_token)
+        local_templates_dir = ensure_dir(local_dir / templates_dir["name"])
+        for tf in template_files:
+            if tf.get("type") != "folder":
+                ft = tf.get("token", "")
+                if ft:
+                    client.drive_download(ft, local_templates_dir)
+
+    return local_dir
+
+
+def build_workspace_dirs(local_dir: Path, directories: list[dict]) -> None:
+    """根据目录结构定义创建本地目录
+
+    Args:
+        local_dir: 工作空间根目录
+        directories: 目录结构列表 [{"name": ..., "depth": ...}, ...]
+    """
+    for d in directories:
+        ensure_dir(local_dir / d["name"])
+
+
+def match_cloud_folder(
+    relative_path: str,
+    workspace_token: str,
+    client: LarkClient | None = None,
+) -> str:
+    """根据本地文件的相对路径，匹配云盘上对应的文件夹 token
+
+    Args:
+        relative_path: 文件相对于工作空间根目录的路径，如 "01_会议纪要/2026-06-16_xxx.md"
+        workspace_token: 工作空间文件夹 token
+        client: LarkClient 实例
+
+    Returns:
+        云盘目标文件夹的 token
+    """
+    client = client or LarkClient()
+    parts = Path(relative_path).parts[:-1]  # 去掉文件名，只保留目录路径
+
+    current_token = workspace_token
+    for part in parts:
+        files = client.drive_list_files(current_token)
+        matched = next(
+            (f for f in files if f.get("name") == part and f.get("type") == "folder"),
+            None
+        )
+        if matched:
+            current_token = matched.get("token", "")
+        else:
+            raise LarkError(f"云盘上未找到对应目录: {part}")
+
+    return current_token