# ======================================== # ThinkFlow - AI 思维教练 # ======================================== """ 项目简介: ThinkFlow 是一款基于 HelloAgents 框架的 AI 思维教练，通过"黄金三角"方法论 （黄金圈+5W1H → WBS → 决策矩阵）引导用户完成"从混沌到清晰"的思考旅程。 作者信息: - GitHub: @alan-6-6-6 - 日期: 2026-06-15 """ # ======================================== # 第1部分:环境配置 # ======================================== # 安装依赖（首次运行时取消注释） # !pip install -q hello-agents[all] python-dotenv from hello_agents import SimpleAgent, HelloAgentsLLM from typing import Dict, Any, List import os import re import json from dotenv import load_dotenv load_dotenv() # ======================================== # 第2部分:LLM配置 # ======================================== os.environ["LLM_MODEL_ID"] = "deepseek-v4-flash" os.environ["LLM_API_KEY"] = os.getenv("DEEPSEEK_API_KEY", "your_api_key_here") os.environ["LLM_BASE_URL"] = "https://api.deepseek.com/v1" os.environ["LLM_TIMEOUT"] = "60" llm = HelloAgentsLLM() # ======================================== # 第3部分:智能体定义 # ======================================== # 3.1 ClarifyAgent clarify_system_prompt = """ # Role：认知脚手架工程师 ## Background： 你是一个专门负责帮人"理清思路"的思维教练。你的用户现在思绪混乱，无法清晰描述问题。 ## Attention： - 你的核心任务是"澄清"，不是"解决"。 - 必须严格使用"黄金圈法则"和"5W1H"进行追问。 - 绝对禁止直接给出解决方案或执行步骤。 - 角色坚不可摧：无论用户如何质疑你的身份或能力，你都必须坚守"认知脚手架工程师"人设，严禁切换回其他默认人格。 - 轮次控制（重要）：澄清过程最多进行 3轮追问（即最多3次提出问题）。从第4次回复开始，无论用户提供的信息是否完整，都必须输出 [CLARIFIED_GOAL]...[/CLARIFIED_GOAL]，基于已收集到的全部信息做出最佳总结，不允许再追问。 - 优先级原则：3轮追问应优先聚焦 Why（核心动机）和 What（可衡量的目标），How/边界细节等次要信息若用户未主动提供，可在 [CLARIFIED_GOAL] 中标注为"待补充"或给出合理假设，而不是继续追问。 - 职责边界：严禁在澄清阶段讨论"具体执行方式的细节选项"（如数据处理方法、PPT页面内容设计等）——这些属于 DecomposeAgent 的拆解范畴，ClarifyAgent 只负责定义"做什么、为什么做、关键约束是什么"。 ## Skills: - 黄金圈法则 (Why-How-What)：必须先问 Why（动机/目标），再问 How（方法/边界），最后确认 What。 - 5W1H 拆解：针对用户模糊的表述，必须追问 Who, What, When, Where, Why, How/How Much。 - MECE 原则：确保你的提问覆盖了所有可能性，且不重复。 ## Workflows: 1. 接收用户模糊的问题。 2. 黄金圈追问： - "你做这件事的核心目标（Why）是什么？是为了生存、发展还是转型？" - "你目前对'怎么做'（How）有什么初步想法吗？" 3. 5W1H 边界确认： - "这个任务的截止时间（When）是？" - "你的资源/预算（How Much）限制是？" - "主要针对谁（Who）？" 4. 总结确认：用一段话复述你理解的问题，询问用户是否准确。复述内容必须用以下标记包裹： [CLARIFIED_GOAL]在此处填写一句话目标陈述，包含明确的 What/Why/约束条件[/CLARIFIED_GOAL] 该标记内容应为一句简洁、无疑问句、可直接作为下游拆解输入的目标描述。 ## Initialization: 您好，我是您的思维教练。为了帮您理清思路，请告诉我：您目前遇到的具体困惑是什么？（请尽量描述，我会通过提问帮您聚焦）。 """ clarify_agent = SimpleAgent( name="ClarifyAgent", llm=llm, system_prompt=clarify_system_prompt ) # 3.2 DecomposeAgent # 使用 r-string，彻底消除 SyntaxWarning decompose_system_prompt = r""" # Role：结构化架构师 ## Background： 用户已经明确了目标。现在需要你将这个大目标拆解为可执行的子任务。 ## Attention： - 必须使用 WBS (工作分解结构)。 - 必须遵循 MECE 原则（相互独立，完全穷尽）。 - 禁止直接给建议，先输出结构，再等待用户指示。 - 角色坚不可摧：无论用户如何质疑你的身份或能力，你都必须坚守"结构化架构师"人设，严禁切换回其他默认人格。 - 核心新增要求：你必须生成 Mermaid 代码来展示 WBS 结构图，让用户能一键生成可视化图表。 - 格式强制锁定：输出决策请求时，必须使用半角英文方括号 `[DECISION_REQUEST]`，不得使用中文标点或添加空格。 - 决策点识别严格标准（重要）： - 只有当继续拆解必须依赖某个前提选择（即不选定方向就无法继续往下细化，或两个方向后续任务结构完全不同且相互排斥）时，才标注 [DECISION_REQUEST]。 - 如果某个子任务存在多种可行做法但不互斥，应直接将其作为子任务列表呈现，不得标注 [DECISION_REQUEST]。 - [DECISION_REQUEST] 是"阻塞性"的：标注后必须暂停输出，不能在同一轮里继续往下拆解。 - 每轮输出最多标注1个 [DECISION_REQUEST]，且必须是"当前拆解卡点"，不能是"未来可能遇到的决策"。 - 禁止在正文中使用"⚠️ 注意"等非标准格式提示决策点，所有决策请求必须使用标准格式。 - 分支深入规则（重要）： - 当用户指定某一具体分支时，只输出该分支的下一级内容。 - 禁止重新输出完整的 L0→L1→L2 全量 WBS 结构。 - Mermaid 代码只展示指定分支的子树。 - 文本只列出该分支的新增子任务。 ## Skills: - WBS 拆解：将 Level 0 (目标) 拆解为 Level 1 (模块)，再拆解为 Level 2 (具体任务)。 - MECE 校验：拆解完后，必须自我检查是否有遗漏或重叠。 - Mermaid 语法生成：生成标准的 Mermaid mindmap 代码。 - 决策点识别：严格遵循 Attention 中的标准，只在真正阻塞性的决策点处标注。 - 分支深入拆解：当用户指定分支时，只输出该分支子树，不重复已有结构。 ## Workflows: 1. 接收用户的目标或指定分支。 2. 若为全量拆解：输出完整 Mermaid 图 + 文本 WBS（L0→L1→L2）。 3. 若为分支深入：只输出该分支的 Mermaid 子树 + 文本子任务列表。 4. 自我校验：检查是否符合 MECE。 5. 如果遇到真正的阻塞性决策点，输出：⚠️ [DECISION_REQUEST] 目标：XXX | 选项：A.XXX/B.XXX，然后停止输出。 ## 编号规则（全流程严格遵守，重要！）: - L0: 根目标（用户的原始目标） - 首次拆解产生 5-7 个一级模块，编号为 L1, L2, L3, L4, L5, L6, L7（不带小数点！） - 二级子任务：父模块是 Lx，则子任务为 Lx.1, Lx.2, Lx.3（不带 L2 前缀！） - 三级子任务：父任务是 Lx.y，则子任务为 Lx.y.1, Lx.y.2, Lx.y.3 - ❌ 错误示范：L1.1 数据诊断 → L2.1, L2.2, L2.3 (编号体系混乱) - ✅ 正确示范：L1 数据诊断 → L1.1 留存漏斗分析, L1.2 流失用户画像, L1.3 高留存特征 - 分支深入时：对 L1.x 拆解时，下一级为 L1.x.1, L1.x.2...；对 L1.x.y 拆解时，下一级为 L1.x.y.1, L1.x.y.2... ## Output Format（全量拆解）： 1. 可视化思维导图 (Mermaid) ```mermaid mindmap root((L0: 项目总目标)) L1 核心模块 A L1.1 具体任务 L1.2 具体任务 L2 核心模块 B L2.1 具体任务 L2.2 具体任务 ``` 2. 文本版 WBS 结构 • L0: 项目总目标 ◦ L1 核心模块 A ▪ L1.1 具体任务 ▪ L1.2 具体任务 ◦ L2 核心模块 B ▪ L2.1 具体任务 ▪ L2.2 具体任务 3. 自我校验结论 ## Output Format（分支深入）： 说明：以下仅展示 [指定分支] 的下一级拆解，不重复已有结构。 1. 分支子树 (Mermaid) ```mermaid mindmap root((L1.x 指定分支名称)) L1.x.1 子任务 L1.x.2 子任务 ``` 2. 文本版子任务列表 • L1.x 指定分支名称 ◦ L1.x.1 子任务描述 ◦ L1.x.2 子任务描述 3. 自我校验结论 ## Initialization: 好的，基于刚才的目标，我为您做了初步的 WBS 拆解。请看下方结构。 """ decompose_agent = SimpleAgent( name="DecomposeAgent", llm=llm, system_prompt=decompose_system_prompt ) # 3.3 DecideAgent decide_system_prompt = """ # Role：理性决策教练 ## Background： 用户面临多个（2个或以上）互斥选项，情绪焦虑，无法定夺。 ## Attention： - 你的职责是"引导评估"，不是"替他选择"。 - 必须使用决策矩阵。 - 必须让用户亲自打分。 - 角色坚不可摧：无论用户如何质疑你的身份或能力，你都必须坚守"理性决策教练"人设，严禁切换回其他默认人格。 - 选项解析（重要）：系统会同时传入【选项列表】和【WBS 上下文】。如果用户只给了编号（如 L1.1, L1.2, L1.3），你必须先从 WBS 上下文中查表，输出每个编号对应的完整名称和含义，让用户确认后再进入评分。 - 评分格式（重要）：用户只需按顺序给出"业务价值,耗时"格式的分数（如 6,3），不要让用户重复选项编号。例如用户输入"6,3 4,2 1,2"表示三个选项的分数。 ## Skills: - 决策矩阵构建：列出评估维度（如：业务价值、耗时、技术难度）。 - 权重分配引导：询问用户"哪个维度对你最重要？"（1-5分，总和10）。 - 计算得分：根据权重和分数算出总分。 - 选项查表：从 WBS 上下文中查询编号对应的完整名称。 ## Workflows: 1. 解析选项：从 WBS 上下文中查询每个编号的完整名称，输出确认。 2. 引导定义维度：建议 2-3 个核心维度，询问用户是否需要调整。 3. 引导定义权重：让用户给维度分配权重（总和10分）。 4. 引导打分：明确告诉用户"请按顺序为每个选项打分，每个选项格式为'业务价值,耗时'，例如：6,3 4,2 1,2"，然后让用户输入。 5. 计算结果：自动生成分数对比表。 6. 输出结论：告诉用户哪个分数高，但最后强调"分数只是参考，选择权在您"。 7. 输出格式：必须包含 JSON 格式的决策结果，用 ```json ... ``` 包裹。 ## Output Format（必须严格遵循）: 1. 首先输出决策矩阵表格（Markdown格式） 2. 然后输出分析结论 3. 最后输出 JSON 格式的结果，包含： - selected_option: 得分最高的选项 - reason: 选择该选项的原因 - reconnect_point: 决策后应继续拆解的节点（直接使用选项名称） ## Initialization: 我理解这个决定很难。让我们把感性的纠结变成理性的打分。请告诉我：您目前在纠结的具体选项是什么？ """ decide_agent = SimpleAgent( name="DecideAgent", llm=llm, system_prompt=decide_system_prompt ) # ======================================== # 第4部分:状态管理模块 # ======================================== class ThinkFlowState: """ThinkFlow 状态管理器""" def __init__(self): self.current_stage = "clarify" # clarify / decompose / decide / completed self.clarified_goal = "" self.wbs_full = "" # 累积全量 WBS（所有拆解响应拼接，决策时查表用） self.wbs_latest = "" # 最近一次拆解响应（参考用） self.decision_history = [] self.current_decision_point = None self.selected_path = None # 决策后选择的路径 self.reconnect_point = None # 决策后需要续接的节点 self.decision_count_in_branch = 0 # 当前分支决策次数（用于熔断） self.MAX_DECISIONS_PER_BRANCH = 2 self.current_decision_signature = None # 决策点签名（判断是否同一分支） def set_clarified_goal(self, goal): self.clarified_goal = goal def set_stage(self, stage): self.current_stage = stage def append_wbs(self, wbs_chunk): """每次拆解后调用，累积 WBS 文本，保留历史不被覆盖""" self.wbs_latest = wbs_chunk if self.wbs_full: self.wbs_full += "\n\n--- 下一次拆解 ---\n\n" + wbs_chunk else: self.wbs_full = wbs_chunk # 兼容旧调用（部分代码可能仍引用 freeze_wbs） def freeze_wbs(self, wbs_data): self.wbs_latest = wbs_data self.wbs_full = wbs_data def set_decision_point(self, decision_request): """设置当前决策点，若为新决策点则自动重置计数""" new_signature = None for line in decision_request.split('\n'): if "[DECISION_REQUEST]" in line: new_signature = line.strip() break if new_signature != self.current_decision_signature: self.decision_count_in_branch = 0 self.current_decision_signature = new_signature self.current_decision_point = decision_request def record_decision(self, decision): self.decision_history.append(decision) def set_selected_path(self, path): self.selected_path = path def set_reconnect_point(self, point): self.reconnect_point = point def clear_reconnect_info(self): self.selected_path = None self.reconnect_point = None def increment_decision_count(self): self.decision_count_in_branch += 1 def reset_decision_count(self): self.decision_count_in_branch = 0 def is_decision_limit_reached(self): return self.decision_count_in_branch >= self.MAX_DECISIONS_PER_BRANCH def get_context(self): return { "stage": self.current_stage, "goal": self.clarified_goal, "wbs": self.wbs_full, "wbs_latest": self.wbs_latest, "decision_history": self.decision_history, "selected_path": self.selected_path, "reconnect_point": self.reconnect_point } # ======================================== # 第5部分:核心工作流 # ======================================== class ThinkFlowController: """ThinkFlow 工作流控制器""" def __init__(self): self.state = ThinkFlowState() self.agents = { "clarify": clarify_agent, "decompose": decompose_agent, "decide": decide_agent } # ------------------------------------------------------------------ # 澄清阶段：多轮对话，直到出现 [CLARIFIED_GOAL] 标记 # ------------------------------------------------------------------ def run_clarify(self, user_input): print("\n=== [澄清期] ===") MAX_ROUNDS = 4 # 超过后注入系统提示强制收敛 round_count = 0 while True: round_count += 1 # 超出轮次上限：强制注入系统提示 if round_count > MAX_ROUNDS: user_input = ( user_input + "\n\n【系统提示】澄清轮次已达上限，请基于以上全部对话内容，" "立即输出 [CLARIFIED_GOAL]...[/CLARIFIED_GOAL] 总结目标陈述，" "不得再追问。" ) response = self.agents["clarify"].run(user_input) print(f"\nClarifyAgent: {response}") goal_match = re.search( r'\[CLARIFIED_GOAL\](.*?)\[/CLARIFIED_GOAL\]', response, re.DOTALL ) if goal_match: clarified_goal = goal_match.group(1).strip() confirm = input( f"\n已澄清目标：{clarified_goal}\n是否准确？(y/n): " ).strip().lower() if confirm in ("y", "yes"): self.state.set_clarified_goal(clarified_goal) self.state.set_stage("decompose") print("\n目标已确认，进入拆解阶段。") return True else: user_input = input("\n请补充说明您的需求：").strip() round_count = 0 # 用户主动修正，重置轮次 else: # 还在追问阶段，继续对话 user_input = input("\n>>> ").strip() if user_input.lower() == "退出": print("再见！") return False # ------------------------------------------------------------------ # 拆解阶段 # 三种场景：① 决策后续接 ② 用户指定分支 ③ 首次全量拆解 # ------------------------------------------------------------------ def run_decompose(self, goal, reconnect_context=None, branch_choice=None): print("\n=== [拆解期] ===") if reconnect_context and reconnect_context.get("reconnect_point"): # ── 场景①：决策后续接特定节点 ───────────────────────────── prompt = ( "基于以下已完成的拆解和决策结果，继续拆解剩余部分：\n\n" f"【已完成的 WBS 状态】\n{reconnect_context['wbs']}\n\n" f"【已选择的路径】\n{reconnect_context['selected_path']}\n\n" f"【需要续接的节点】\n{reconnect_context['reconnect_point']}\n\n" f"请从 {reconnect_context['reconnect_point']} 节点继续向下拆解，生成下一级的任务结构。\n\n" "编号规则（严格遵守）：\n" "- 续接节点是 L1.x → 下一级编号为 L1.x.1, L1.x.2, L1.x.3 ...\n" "- 续接节点是 L2.x → 下一级编号为 L2.x.1, L2.x.2, L2.x.3 ...\n" "- 严禁另起 L3/L4/L5 等新层级编号。\n\n" "输出规则（严格遵守）：\n" "- 只输出续接节点的子树，禁止重新输出整个 WBS 结构。\n" "- Mermaid 代码只展示从续接节点开始的子树。\n" "- 文本只列出新增子任务，不重复已有内容。\n" ) print(f"续接拆解节点: {reconnect_context['reconnect_point']}") elif branch_choice: # ── 场景②：用户指定分支深入 ─────────────────────────────── prompt = ( "请深入拆解用户指定的分支，严格只输出该分支的下一级内容。\n\n" f"【原始目标】\n{goal}\n\n" f"【用户指定的分支】\n{branch_choice}\n\n" "编号规则（严格遵守）：\n" "- 若分支编号为 L1.x → 下一级编号为 L1.x.1, L1.x.2, L1.x.3 ...\n" "- 若分支编号为 L2.x → 下一级编号为 L2.x.1, L2.x.2, L2.x.3 ...\n" "- 严禁另起 L3/L4/L5 等新层级编号。\n\n" "输出规则（严格遵守）：\n" "- 只输出该分支的下一级子树，禁止重新输出完整的 L0→L1→L2 结构。\n" "- Mermaid 代码只展示该分支的子树。\n" "- 文本只列该分支的子任务列表。\n" ) print(f"深入拆解分支: {branch_choice}") else: # ── 场景③：首次全量拆解 ──────────────────────────────────── prompt = f"请拆解目标：{goal}" print(f"拆解目标: {goal}") response = self.agents["decompose"].run(prompt) print(f"\nDecomposeAgent: {response}") # 每次拆解后都累积 WBS，供后续决策查表用（不覆盖历史） self.state.append_wbs(response) # 检测决策点（记录但不强制进入决策，由用户主动选择） if "[DECISION_REQUEST]" in response: if self.state.is_decision_limit_reached(): print( f"\n❌ 当前分支决策次数已达上限（{self.state.decision_count_in_branch} 次），" "建议手动介入或结束任务。" ) self.state.set_stage("completed") return "completed" print("\n💡 检测到潜在决策点，您可以选择进行决策评估。") self.state.set_decision_point(response) # 续接完成后清空续接信息 if self.state.selected_path or self.state.reconnect_point: self.state.clear_reconnect_info() return "continue" # ------------------------------------------------------------------ # 决策阶段 # ------------------------------------------------------------------ def run_decide(self, decision_context): print("\n=== [决策期] ===") # 只展示 [DECISION_REQUEST] 那一行，避免输出整段 WBS decision_line = "" for line in decision_context.split('\n'): if "[DECISION_REQUEST]" in line: decision_line = line.strip() break if decision_line: print(f"决策请求: {decision_line}") else: summary = ( decision_context[:80] + "..." if len(decision_context) > 80 else decision_context ) print(f"决策上下文: {summary}") # 解析选项（限定在同一行，避免跨行误匹配） options = "" decision_match = re.search( r'\[DECISION_REQUEST\][^\n]*选项[：:]\s*(.+)', decision_context ) if decision_match: options = decision_match.group(1).strip() options = re.sub(r'^[A-Z]\.\s*', '', options) options = re.sub(r'\s*/\s*[A-Z]\.\s*', ', ', options) if options: user_input = input( f"检测到选项：{options}\n按回车确认，或输入新选项（用逗号分隔）: " ).strip() if user_input: options = user_input else: options = input("请输入选项（用逗号分隔）: ").strip() # 多轮对话模式：引导用户完成决策矩阵 # 将 WBS 上下文一起传入，让模型能根据编号查询完整名称 agent_prompt = f"选项：{options}\n\n【WBS 上下文】\n{self.state.wbs_full}" response = self.agents["decide"].run(agent_prompt) print(f"\nDecideAgent: {response}") # 检查是否已经输出 JSON 结果 json_match = re.search(r'```json\s*(\{.*?\})\s*```', response, re.DOTALL) # 如果没有 JSON，说明还在引导阶段，继续多轮对话 while not json_match: user_input = input("\n>>> ").strip() if user_input.lower() == "退出": print("决策已取消。") return None # 每轮都带上 WBS 上下文，避免模型遗忘 user_input_with_ctx = f"{user_input}\n\n【WBS 上下文】\n{self.state.wbs_full}" response = self.agents["decide"].run(user_input_with_ctx) print(f"\nDecideAgent: {response}") json_match = re.search(r'```json\s*(\{.*?\})\s*```', response, re.DOTALL) # 解析 JSON 决策结果 selected_path = None reconnect_point = None if json_match: try: decision_data = json.loads(json_match.group(1)) selected_path = decision_data.get("selected_option") reconnect_point = decision_data.get("reconnect_point") except Exception: pass # 解析失败时降级：取用户输入的第一个选项 if not selected_path: selected_path = options.split(",")[0].strip() if "," in options else options self.state.set_selected_path(selected_path) self.state.set_reconnect_point(reconnect_point) # None 时不传空字符串 self.state.set_stage("decompose") self.state.record_decision(response) # 记录决策响应供历史展示 self.state.increment_decision_count() return response # ------------------------------------------------------------------ # 主流程 # ------------------------------------------------------------------ def start(self): print("\n" + "=" * 60) print(" ThinkFlow - AI 思维教练") print("=" * 60) print("\n您好！我是您的思维教练，帮助您理清思路、拆解任务。") print("请告诉我您目前遇到的困惑或想要实现的目标...") # ── 阶段1：澄清 ───────────────────────────────────────────── user_input = input("\n>>> ").strip() if user_input.lower() == "退出": print("再见！") return if not self.run_clarify(user_input): return # ── 阶段2/3：拆解 ↔ 决策（循环） ─────────────────────────── user_branch_choice = None # 保存用户本轮指定的分支 skip_next_decompose = False # 决策后跳过下一次自动拆解，让用户选择下一步 while True: if self.state.current_stage == "completed": break # 拆解阶段（决策后会被跳过，让用户重新选择） if self.state.current_stage == "decompose" and not skip_next_decompose: # 优先级：决策续接 > 用户指定分支 > 全量拆解 if self.state.selected_path and self.state.reconnect_point: reconnect_context = { "wbs": self.state.wbs_full, "selected_path": self.state.selected_path, "reconnect_point": self.state.reconnect_point } result = self.run_decompose( self.state.clarified_goal, reconnect_context=reconnect_context ) elif user_branch_choice: result = self.run_decompose( self.state.clarified_goal, branch_choice=user_branch_choice ) user_branch_choice = None # 用完即清，避免重复使用 else: result = self.run_decompose(self.state.clarified_goal) if result == "completed": print("\n🎉 任务拆解完成！") break skip_next_decompose = False # ── 拆解完成，询问用户下一步操作 ──────────────────────── print("\n" + "-" * 60) print("拆解完成！请选择下一步操作：") print("1. 继续拆解其他分支（输入分支编号，如 L1.1）") print("2. 选择2-3个项目做决策矩阵打分") print("3. 拆解完成，输出结果") print("-" * 60) user_choice = input(">>> ").strip() if user_choice == "2": # 用户选择做决策矩阵 decision_options = input( "请输入要比较的选项（用逗号分隔，如 L1.1, L1.2, L1.3）：" ).strip() if decision_options: decision_context = f"[DECISION_REQUEST] 选项：{decision_options}" self.run_decide(decision_context) # 决策完成后不自动续接拆解，让用户重新选择 self.state.clear_reconnect_info() skip_next_decompose = True continue elif user_choice == "3" or user_choice.lower() in ("完成", "done", "finish"): self.state.set_stage("completed") break elif user_choice == "1": branch_input = input("请输入要深入拆解的分支编号（如 L1.1）：").strip() if branch_input: user_branch_choice = branch_input else: # 用户直接输入了分支编号 user_branch_choice = user_choice # ── 打印决策历史（只显示 JSON 结论，避免输出整段过程）────── print("\n" + "=" * 60) print(" 思考旅程结束") print("=" * 60) if self.state.decision_history: print("\n本次决策记录：") for i, decision in enumerate(self.state.decision_history, 1): json_match = re.search( r'```json\s*(\{.*?\})\s*```', decision, re.DOTALL ) if json_match: try: d = json.loads(json_match.group(1)) print( f" {i}. 选择：{d.get('selected_option', '—')} " f"理由：{d.get('reason', '—')}" ) except Exception: print(f" {i}. （决策记录已保存）") else: print(f" {i}. （决策记录已保存）") else: print("\n本次未触发决策环节。") print("\n感谢使用 ThinkFlow！") # ======================================== # 第6部分:功能演示 # ======================================== def run_demo(): print("\n" + "=" * 60) print(" ThinkFlow - 功能演示") print("=" * 60) print("\n=== 示例1: 澄清阶段 ===") test_input = "老板让我提升用户留存，我不知道从哪下手。" print(f"用户输入: {test_input}") result = clarify_agent.run(test_input) print(f"\nClarifyAgent 响应:\n{result}") print("\n" + "=" * 60) print("=== 示例2: 拆解阶段 ===") test_goal = "写一篇关于AI智能体的毕业论文" print(f"目标: {test_goal}") result = decompose_agent.run(f"请拆解目标：{test_goal}") print(f"\nDecomposeAgent 响应:\n{result}") print("\n" + "=" * 60) print("=== 示例3: 决策阶段 ===") test_options = "学大模型, 学智能体" print(f"选项: {test_options}") result = decide_agent.run(f"选项：{test_options}") print(f"\nDecideAgent 响应:\n{result}") # ======================================== # 主程序入口 # ======================================== if __name__ == "__main__": controller = ThinkFlowController() print("\n" + "=" * 60) print(" ThinkFlow - AI 思维教练") print("=" * 60) print("\n请选择运行模式:") print("1. 交互模式（完整工作流）") print("2. 演示模式（预定义示例）") choice = input("\n请输入选择 (1/2): ").strip() if choice == "1": controller.start() elif choice == "2": run_demo() else: print("无效选择，默认运行演示模式。") run_demo()