给Agent CLI加上Plan-and-Execute，让Agent先规划后执行，支持DAG。

大家好，我是二哥呀。

PaiCLI 的第 1 期我们已经实现了，一个基础的 ReAct Agent，能一步一步执行任务，一边思考一边行动。

但这种方式有个问题：复杂任务需要很多轮对话，每一步都需要调用 LLM。

比如“创建一个 Spring Boot 项目，写个 REST API，然后打包运行”这个任务：

一共要调用 5 次 LLM，每次都要等网络往返。

第 2 期，我们来实现 Plan-and-Execute 模式：先让 LLM 制定完整计划，然后按步骤执行，中间不再反复询问 LLM。

01、Plan-and-Execute 的核心思想

Plan-and-Execute 模式来自论文《Plan-and-Solve Prompting》。

核心思想是规划和执行分离。

这样做的好处有：

1. 减少 LLM 调用次数：规划一次，执行多次
2. 可预测性更强：提前知道整个执行流程
3. 支持并行执行：识别无依赖的任务并行处理
4. 失败可重试：某步失败可以单独重试，不用从头来

代价是灵活性降低，如果执行过程中发现计划有问题，需要重新规划。

02、任务建模

要实现 Plan-and-Execute，首先要定义什么是“任务”。

为什么需要任务建模

在 ReAct 模式中，任务隐含在对话历史中。LLM 通过阅读历史消息知道当前该做什么。但这种方式有两个问题：

第一，上下文膨胀。复杂任务需要很多轮对话，随着历史消息越来越长，Token 的消耗剧增。

第二，状态不清晰。对话历史里混杂了思考过程、工具调用、执行结果，很难一眼看出任务执行到哪一步。

任务建模把“做什么”和“怎么做”分离开来。计划阶段确定“做什么”（任务列表），执行阶段解决“怎么做”（具体执行）。

Task 类设计

public class Task {
    private final String id;              // 任务唯一标识
    private final String description;     // 任务描述
    private final TaskType type;          // 任务类型
    private TaskStatus status;            // 执行状态
    private String result;                // 执行结果
    private String error;                 // 错误信息
    private final List dependencies;  // 依赖的任务ID
    private final List dependents;    // 被依赖的任务ID
    private long startTime;               // 开始时间
    private long endTime;                 // 结束时间
}

任务类型我们定义了 6 种：

• PLANNING：规划任务，用于分析和决策
• FILE_READ：读取文件，获取信息
• FILE_WRITE：写入文件，输出结果
• COMMAND：执行命令，编译运行等
• ANALYSIS：分析结果，中间决策
• VERIFICATION：验证结果，检查正确性

任务状态有 5 种：

• PENDING：等待执行
• RUNNING：执行中
• COMPLETED：已完成
• FAILED：执行失败
• SKIPPED：被跳过（依赖失败）

任务的生命周期

一个任务从创建到完成，完整的生命周期如下所示：

PENDING → RUNNING → COMPLETED/FAILED/SKIPPED

每个状态转换都有对应的方法：

public void markStarted() {
    this.status = TaskStatus.RUNNING;
    this.startTime = System.currentTimeMillis();
}

public void markCompleted(String result) {
    this.status = TaskStatus.COMPLETED;
    this.result = result;
    this.endTime = System.currentTimeMillis();
}

public void markFailed(String error) {
    this.status = TaskStatus.FAILED;
    this.error = error;
    this.endTime = System.currentTimeMillis();
}

记录时间戳有两个用途：一是统计执行耗时，二是分析任务瓶颈。如果某个任务总是耗时很长，可能需要优化或者拆分。

依赖关系

复杂任务有先后依赖。比如“写代码”依赖“创建项目”，“运行”依赖“编译”。

我们用 DAG（有向无环图）表示依赖关系：

每个任务可以声明自己依赖哪些任务（dependencies），系统会自动计算出执行顺序。

依赖关系的核心方法是 isExecutable：

public boolean isExecutable(Map allTasks) {
    if (status != TaskStatus.PENDING) return false;
    for (String depId : dependencies) {
        Task dep = allTasks.get(depId);
        if (dep == null || dep.getStatus() != TaskStatus.COMPLETED) {
            return false;
        }
    }
    return true;
}

只有当所有依赖都已完成时，任务才可以执行。这个简单的检查保证了执行顺序的正确性。

任务类型我们定义了 6 种：

• PLANNING：规划任务
• FILE_READ：读取文件
• FILE_WRITE：写入文件
• COMMAND：执行命令
• ANALYSIS：分析结果
• VERIFICATION：验证结果

依赖关系

复杂任务有先后依赖。比如“写代码”依赖“创建项目”，“运行”依赖“编译”。

我们用 DAG（有向无环图）来表示依赖关系：

每个任务可以声明自己依赖哪些任务（dependencies），系统会自动计算出执行顺序。

执行计划

多个任务可以组成一个执行计划：

public class ExecutionPlan {
    private final String id;
    private final String goal;           // 计划目标
    private final Map tasks;  // 所有任务
    private final List executionOrder;  // 执行顺序
    private PlanStatus status;
    private String summary;
}

拓扑排序算法

核心方法是 computeExecutionOrder()，使用拓扑排序算法把 DAG 转换成线性执行顺序。

拓扑排序的基本思想是：

1. 找到所有入度为 0 的节点（没有依赖的任务）
2. 把这些节点加入结果列表
3. 移除这些节点及其出边
4. 重复 1-3，直到所有节点都处理完

我们用 DFS 算法来实现：

public boolean computeExecutionOrder() {
    executionOrder.clear();
    Set visited = new HashSet<>();
    Set