aico-cli 0.2.5 → 0.2.7

package/dist/chunks/feature-checker.mjs

@@ -95,7 +95,6 @@ async function checkAiPersonalityFeature() {
   try {
     const requiredFiles = [
       "personality.md",
-      "base.md",
       "language.md",
       "CLAUDE.md"
     ];

package/dist/chunks/simple-config.mjs

@@ -13,7 +13,7 @@ import { join as join$1 } from 'node:path';
 import { join, dirname, basename } from 'pathe';
 import { fileURLToPath } from 'node:url';
 
-const version = "0.2.5";
+const version = "0.2.7";
 
 function displayBanner(subtitle) {
   const defaultSubtitle = "\u4E00\u952E\u914D\u7F6E\u4F60\u7684\u5F00\u53D1\u73AF\u5883";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aico-cli",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "packageManager": "pnpm@9.15.9",
   "description": "AI CLI",
   "repository": {

package/templates/agents/aico/requirement/task-executor.md

@@ -5,7 +5,7 @@ tools: Read, Write, Bash
 color: purple
 ---
 
-# 任务自动执行智能体 - 跨平台版本
+# 任务自动执行智能体
 
 遵循"领取-执行-验证-报告"的循环流程，自动执行开发任务清单中的原子任务。
 
@@ -54,8 +54,20 @@ color: purple
 
 ```bash
 # 读取任务清单 - 跨平台兼容
-source "$(dirname "$0")/crossplatform-utils.sh"
-safe_read_file ".aico/docs/[需求名称]/开发任务清单.md"
+source "$(dirname "$0")/../../utils/task-manager.sh"
+
+# 获取可用任务列表
+available_tasks=$(main list ".aico/docs/[需求名称]/开发任务清单.md")
+
+# 选择任务并原子领取
+for task_id in $available_tasks; do
+    if main check-deps ".aico/docs/[需求名称]/开发任务清单.md" "$task_id"; then
+        if main acquire ".aico/docs/[需求名称]/开发任务清单.md" "$task_id"; then
+            echo "成功领取任务: $task_id"
+            break
+        fi
+    fi
+done
 ```
 
 **任务选择逻辑：**
@@ -220,6 +232,9 @@ case "$PM" in
     *) echo "跳过语法检查 - 包管理器: $PM" ;;
 esac
 
+# 记录验证结果用于最终状态更新
+validation_result=$?
+
 # TypeScript编译检查
 case "$PM" in
     npm) npm run type-check 2>/dev/null ;;
@@ -265,6 +280,13 @@ esac
 ### 阶段五：执行报告生成
 
 ```bash
+# 更新任务状态 - 跨平台兼容
+if [ "$validation_result" -eq 0 ]; then
+    main complete ".aico/docs/[需求名称]/开发任务清单.md" "$task_id" "成功"
+else
+    main fail ".aico/docs/[需求名称]/开发任务清单.md" "$task_id" "验证失败"
+fi
+
 # 更新任务完成报告 - 跨平台兼容
 cat >> ".aico/docs/[需求名称]/开发任务完成报告.md" << 'EOF'
 

package/templates/agents/aico/requirement/task-splitter-validator.md

@@ -153,13 +153,27 @@ graph TD
 
 ## 📋 详细任务清单
 
+### 任务模板
+- **任务ID**: 任务唯一标识 (e.g., `DB-001`, `BE-001`)
+- **状态**: 待执行 | 执行中 | 已完成 | 失败
+- **优先级**: 🔴 高 | 🟡 中 | 🟢 低
+- **依赖**: 依赖的任务ID列表
+- **执行者**: 领取任务的执行者ID
+- **开始时间**: 任务开始执行的时间
+- **完成时间**: 任务完成或失败的时间
+- **结果**: 成功 | 失败 | [其他]
+
 ### 🗄️ 数据层任务
 
 #### 任务A: 数据库迁移
-**ID**: `DB-001`  
-**优先级**: 🔴 高  
-**依赖**: 无  
-**预估时间**: 30分钟
+- **任务ID**: `DB-001`
+- **状态**: 待执行
+- **优先级**: 🔴 高
+- **依赖**: 无
+- **执行者**:
+- **开始时间**:
+- **完成时间**:
+- **结果**:
 
 **具体操作**：
 1. 创建数据库迁移文件 `migrations/001_add_new_table.sql`

package/templates/commands/aico/requirement.md

@@ -13,7 +13,7 @@ argument-hint: <需求描述>
 作为需求管理的指挥官，统筹整个需求从识别、对齐、拆分到执行的全生命周期：
 
 - 🎯 **需求识别**：深度理解用户意图，生成共识文档
-- 🔄 **需求对齐**：分析现有代码库，制定技术实施方案  
+- 🔄 **需求对齐**：分析现有代码库，制定技术实施方案
 - 📋 **任务拆分**：将需求分解为可执行的原子任务
 - ⚡ **自动执行**：按依赖关系自动执行开发任务
 - ✅ **质量保障**：全程质量评估和验证
@@ -28,14 +28,19 @@ argument-hint: <需求描述>
 
 1. **识别阶段**：用户提供新需求描述 → 调用 `requirement-identifier`
    - 必须生成 `.aico/docs/[需求名称]/共识文档.md`
-   - 必须等待用户确认后，才能进入下一阶段
-2. **对齐阶段**：存在共识文档但无技术方案 → 调用 `requirement-aligner`
+   - 文档状态必须设置为`待确认`
+   - 必须等待用户确认后，自动更新状态为`已确认`并进入下一阶段
+2. **对齐阶段**：存在共识文档且状态为`已确认`但无技术方案 → 调用 `requirement-aligner`
+   - 必须存在 `.aico/docs/[需求名称]/共识文档.md`并且需求状态为`已确认`
    - 必须生成 `.aico/docs/[需求名称]/技术对齐方案文档.md`
-   - 必须等待用户确认后，才能进入下一阶段  
-3. **拆分阶段**：存在技术方案但无任务清单 → 调用 `task-splitter-validator`
+   - 文档状态必须设置为`待确认`
+   - 必须等待用户确认后，自动更新状态为`已确认`并进入下一阶段
+3. **拆分阶段**：存在技术方案且状态为`已确认`但无任务清单 → 调用 `task-splitter-validator`
+   - 必须存在 `.aico/docs/[需求名称]/技术对齐方案文档.md`并且状态为`已确认`
    - 必须生成 `.aico/docs/[需求名称]/开发任务清单.md`
-   - 必须等待用户确认后，才能进入下一阶段
-4. **执行阶段**：存在任务清单且有待执行任务 → 调用 `task-executor`
+   - 文档状态必须设置为`待确认`
+   - 必须等待用户确认后，自动更新状态为`已确认`并进入下一阶段
+4. **执行阶段**：存在任务清单且状态为`已确认`且有待执行任务 → 调用 `task-executor`
 5. **验证阶段**：任务执行后需要质量评估 → 调用 `task-executor-validator`
 
 ### 智能体调用参数
@@ -44,19 +49,23 @@ argument-hint: <需求描述>
   - `user_input`: $ARGUMENTS
   - `current_timestamp`: (来自步骤1的时间戳)
   - `project_context`: (当前项目的 CLAUDE.md 信息)
+  - `document_status`: `待确认`
 
 - **requirement-aligner**：
   - `consensus_document_path`: `.aico/docs/[需求名称]/共识文档.md`
   - `current_timestamp`: (来自步骤1的时间戳)
+  - `document_status`: `待确认`
 
 - **task-splitter-validator**：
   - `consensus_document_path`: `.aico/docs/[需求名称]/共识文档.md`
   - `technical_alignment_path`: `.aico/docs/[需求名称]/技术对齐方案文档.md`
   - `current_timestamp`: (来自步骤1的时间戳)
+  - `document_status`: `待确认`
 
 - **task-executor**：
   - `task_list_path`: `.aico/docs/[需求名称]/开发任务清单.md`
   - `current_timestamp`: (来自步骤1的时间戳)
+  - `document_status`: `已确认`
 
 - **task-executor-validator**：
   - `task_list_path`: `.aico/docs/[需求名称]/开发任务清单.md`

package/templates/personality.md

@@ -52,10 +52,8 @@ description: 架构师级软件工程师，以工程卓越为信仰，为追求
 
 #### 开发方法论
 **测试驱动开发 (TDD)**
-- 测试优先：所有功能实现前必须编写测试用例
+- 测试优先：所有功能实现前必须编写测试脚本，执行脚本成功后清除测试脚本
 - 红绿重构：严格执行失败→通过→重构的开发节奏
-- 覆盖率要求：核心逻辑≥90%，API接口100%覆盖
-- Git追溯：提交历史清晰展现测试先行轨迹
 
 **规范驱动开发**
 - 需求纯净：专注业务需求，避免技术实现污染
@@ -111,7 +109,7 @@ description: 架构师级软件工程师，以工程卓越为信仰，为追求
 **TODO清单标准流程：**
 1. **需求分析**：明确用户需求的核心目标和约束条件
 2. **环境评估**：分析当前工作环境和可用工具
-3. **方案设计**：制定技术方案和实现策略  
+3. **方案设计**：制定技术方案和实现策略
 4. **风险评估**：识别潜在技术难点和解决方案
 5. **执行验证**：按计划执行并验证结果
 6. **总结反馈**：输出最终解决方案和优化建议

package/templates/utils/task-manager.sh

@@ -0,0 +1,401 @@
+#!/usr/bin/env bash
+
+# 跨平台任务管理器 - 支持 Windows (Git Bash/Cygwin/WSL), Linux, macOS
+
+set -euo pipefail
+
+# 检测平台类型
+detect_platform() {
+    case "$(uname -s)" in
+        Darwin)
+            echo "macos"
+            ;;
+        Linux)
+            if grep -q "Microsoft" /proc/version 2>/dev/null; then
+                echo "wsl"
+            else
+                echo "linux"
+            fi
+            ;;
+        CYGWIN*|MINGW*|MSYS*)
+            echo "windows"
+            ;;
+        *)
+            echo "unknown"
+            ;;
+    esac
+}
+
+# 获取临时目录（跨平台兼容）
+get_temp_dir() {
+    local platform="$(detect_platform)"
+    case "$platform" in
+        windows|cygwin|mingw|msys)
+            # Windows 系统
+            if [ -n "${TEMP:-}" ]; then
+                echo "$TEMP"
+            elif [ -n "${TMP:-}" ]; then
+                echo "$TMP"
+            else
+                echo "/tmp"
+            fi
+            ;;
+        *)
+            # Unix-like 系统
+            echo "/tmp"
+            ;;
+    esac
+}
+
+# 安全的文件操作（跨平台兼容）
+safe_file_operation() {
+    local operation="$1"
+    local file_path="$2"
+    local content="${3:-}"
+
+    case "$operation" in
+        read)
+            if [ -f "$file_path" ]; then
+                cat "$file_path" 2>/dev/null || echo ""
+            else
+                echo ""
+            fi
+            ;;
+        write)
+            mkdir -p "$(dirname "$file_path")"
+            echo "$content" > "$file_path"
+            ;;
+        append)
+            mkdir -p "$(dirname "$file_path")"
+            echo "$content" >> "$file_path"
+            ;;
+        lock)
+            # 文件锁定机制（跨平台兼容）
+            local lock_file="$file_path.lock"
+            local timeout=${4:-30}
+            local start_time=$(date +%s)
+
+            while [ -f "$lock_file" ]; do
+                local current_time=$(date +%s)
+                local elapsed=$((current_time - start_time))
+
+                if [ $elapsed -ge $timeout ]; then
+                    echo "锁定超时: $file_path" >&2
+                    return 1
+                fi
+                sleep 1
+            done
+
+            touch "$lock_file"
+            ;;
+        unlock)
+            rm -f "$file_path.lock" 2>/dev/null || true
+            ;;
+    esac
+}
+
+# 原子任务领取
+task_acquire() {
+    local task_list_path="$1"
+    local task_id="$2"
+    local executor_id="${3:-$(hostname)-$(date +%s)}"
+
+    # 锁定任务清单文件
+    safe_file_operation lock "$task_list_path"
+
+    # 读取任务清单
+    local task_list_content="$(safe_file_operation read "$task_list_path")"
+
+    # 查找任务并检查状态
+    if echo "$task_list_content" | grep -q "$task_id"; then
+        local task_status=$(echo "$task_list_content" | awk -v id="$task_id" '
+            $0 ~ id {
+                for(i=1; i<=NF; i++) {
+                    if ($i ~ /^状态:/) {
+                        gsub(/状态:/, "", $i)
+                        print $i
+                        exit
+                    }
+                }
+            }'
+        )
+
+        # 检查任务状态
+        if [ "$task_status" = "待执行" ]; then
+            # 更新任务状态为执行中
+            local updated_content=$(echo "$task_list_content" | awk -v id="$task_id" -v executor="$executor_id" -v timestamp="$(date +'%Y-%m-%d %H:%M:%S')" '
+                $0 ~ id {
+                    gsub(/状态:待执行/, "状态:执行中")
+                    gsub(/执行者:/, "执行者:" executor " 开始时间:" timestamp)
+                }
+                { print }
+            ')
+
+            safe_file_operation write "$task_list_path" "$updated_content"
+            echo "任务领取成功: $task_id"
+            return 0
+        else
+            echo "任务状态不可领取: $task_status" >&2
+            return 1
+        fi
+    else
+        echo "任务不存在: $task_id" >&2
+        return 1
+    fi
+
+    # 解锁文件
+    safe_file_operation unlock "$task_list_path"
+}
+
+# 原子任务完成
+task_complete() {
+    local task_list_path="$1"
+    local task_id="$2"
+    local result="${3:-成功}"
+
+    safe_file_operation lock "$task_list_path"
+
+    local task_list_content="$(safe_file_operation read "$task_list_path")"
+
+    local updated_content=$(echo "$task_list_content" | awk -v id="$task_id" -v result="$result" -v timestamp="$(date +'%Y-%m-%d %H:%M:%S')" '
+        $0 ~ id {
+            gsub(/状态:执行中/, "状态:已完成")
+            gsub(/执行者:[^ ]*/, "& 完成时间:" timestamp " 结果:" result)
+        }
+        { print }
+    ')
+
+    safe_file_operation write "$task_list_path" "$updated_content"
+
+    safe_file_operation unlock "$task_list_path"
+    echo "任务完成: $task_id - $result"
+}
+
+# 原子任务失败
+task_fail() {
+    local task_list_path="$1"
+    local task_id="$2"
+    local error_message="$3"
+
+    safe_file_operation lock "$task_list_path"
+
+    local task_list_content="$(safe_file_operation read "$task_list_path")"
+
+    local updated_content=$(echo "$task_list_content" | awk -v id="$task_id" -v error="$error_message" -v timestamp="$(date +'%Y-%m-%d %H:%M:%S')" '
+        $0 ~ id {
+            gsub(/状态:执行中/, "状态:失败")
+            gsub(/执行者:[^ ]*/, "& 失败时间:" timestamp " 错误:" error)
+        }
+        { print }
+    ')
+
+    safe_file_operation write "$task_list_path" "$updated_content"
+
+    safe_file_operation unlock "$task_list_path"
+    echo "任务失败: $task_id - $error_message" >&2
+    return 1
+}
+
+# 获取可执行任务列表
+get_available_tasks() {
+    local task_list_path="$1"
+
+    safe_file_operation lock "$task_list_path"
+
+    local task_list_content="$(safe_file_operation read "$task_list_path")"
+
+    # 提取状态为"待执行"的任务
+    echo "$task_list_content" | awk '
+        /^#### 任务[A-Za-z0-9-]+:/ {
+            task_id = $2
+            gsub(/:/, "", task_id)
+            status = ""
+            in_task = 1
+        }
+        in_task && /^状态:/ {
+            status = $0
+            gsub(/状态:/, "", status)
+            gsub(/^[ \t]+|[ \t]+$/, "", status)
+        }
+        in_task && /^---$/ {
+            if (status == "待执行") {
+                print task_id
+            }
+            in_task = 0
+            status = ""
+        }
+    '
+
+    safe_file_operation unlock "$task_list_path"
+}
+
+# 检查任务依赖是否满足
+check_task_dependencies() {
+    local task_list_path="$1"
+    local task_id="$2"
+
+    safe_file_operation lock "$task_list_path"
+
+    local task_list_content="$(safe_file_operation read "$task_list_path")"
+
+    # 提取任务的依赖
+    local dependencies=$(echo "$task_list_content" | awk -v id="$task_id" '
+        $0 ~ id {
+            for(i=1; i<=NF; i++) {
+                if ($i ~ /^依赖:/) {
+                    # 打印依赖行并退出
+                    print $0
+                    exit
+                }
+            }
+        }
+    ')
+
+    # 提取依赖的任务ID
+    local dep_tasks=$(echo "$dependencies" | grep -oE '[A-Z]+-[0-9]+' || true)
+
+    # 检查每个依赖任务的状态
+    local all_deps_completed=true
+    for dep_task in $dep_tasks; do
+        local dep_status=$(echo "$task_list_content" | awk -v id="$dep_task" '
+            $0 ~ id {
+                for(i=1; i<=NF; i++) {
+                    if ($i ~ /^状态:/) {
+                        gsub(/状态:/, "", $i)
+                        print $i
+                        exit
+                    }
+                }
+            }
+        ')
+
+        if [ "$dep_status" != "已完成" ]; then
+            echo "依赖任务未完成: $dep_task (状态: $dep_status)" >&2
+            all_deps_completed=false
+        fi
+    done
+
+    safe_file_operation unlock "$task_list_path"
+
+    $all_deps_completed
+}
+
+# 并行任务执行协调器
+parallel_task_executor() {
+    local task_list_path="$1"
+    local max_parallel="${2:-3}"
+
+    echo "开始并行任务执行 (最大并行数: $max_parallel)"
+
+    while true; do
+        # 获取可用任务
+        local available_tasks=$(get_available_tasks "$task_list_path")
+
+        if [ -z "$available_tasks" ]; then
+            echo "所有任务已完成"
+            break
+        fi
+
+        local running_tasks=0
+        local completed_tasks=0
+
+        # 检查当前运行中的任务数
+        safe_file_operation lock "$task_list_path"
+        local task_list_content="$(safe_file_operation read "$task_list_path")"
+        running_tasks=$(echo "$task_list_content" | grep -c "状态:执行中" || true)
+        completed_tasks=$(echo "$task_list_content" | grep -c "状态:已完成" || true)
+        safe_file_operation unlock "$task_list_path"
+
+        # 如果还有并行空间，领取新任务
+        if [ $running_tasks -lt $max_parallel ]; then
+            for task_id in $available_tasks; do
+                if [ $running_tasks -ge $max_parallel ]; then
+                    break
+                fi
+
+                # 检查任务依赖
+                if check_task_dependencies "$task_list_path" "$task_id"; then
+                    # 尝试领取任务
+                    if task_acquire "$task_list_path" "$task_id" 2>/dev/null; then
+                        echo "开始执行任务: $task_id"
+                        # 在实际使用中，这里会调用具体的任务执行逻辑
+                        ((running_tasks++))
+                    fi
+                fi
+            done
+        fi
+
+        # 等待一段时间再检查
+        sleep 5
+    done
+}
+
+# 主函数
+main() {
+    local command="${1:-help}"
+    local task_list_path="${2:-}"
+    local task_id="${3:-}"
+
+    case "$command" in
+        acquire)
+            if [ -z "$task_list_path" ] || [ -z "$task_id" ]; then
+                echo "用法: $0 acquire <任务清单路径> <任务ID>" >&2
+                exit 1
+            fi
+            task_acquire "$task_list_path" "$task_id"
+            ;;
+        complete)
+            if [ -z "$task_list_path" ] || [ -z "$task_id" ]; then
+                echo "用法: $0 complete <任务清单路径> <任务ID> [结果]" >&2
+                exit 1
+            fi
+            task_complete "$task_list_path" "$task_id" "${4:-成功}"
+            ;;
+        fail)
+            if [ -z "$task_list_path" ] || [ -z "$task_id" ]; then
+                echo "用法: $0 fail <任务清单路径> <任务ID> <错误信息>" >&2
+                exit 1
+            fi
+            task_fail "$task_list_path" "$task_id" "$4"
+            ;;
+        list)
+            if [ -z "$task_list_path" ]; then
+                echo "用法: $0 list <任务清单路径>" >&2
+                exit 1
+            fi
+            get_available_tasks "$task_list_path"
+            ;;
+        parallel)
+            if [ -z "$task_list_path" ]; then
+                echo "用法: $0 parallel <任务清单路径> [最大并行数]" >&2
+                exit 1
+            fi
+            parallel_task_executor "$task_list_path" "${4:-3}"
+            ;;
+        check-deps)
+            if [ -z "$task_list_path" ] || [ -z "$task_id" ]; then
+                echo "用法: $0 check-deps <任务清单路径> <任务ID>" >&2
+                exit 1
+            fi
+            check_task_dependencies "$task_list_path" "$task_id"
+            ;;
+        *|help)
+            echo "跨平台任务管理器"
+            echo "用法: $0 <命令> [参数]"
+            echo ""
+            echo "命令:"
+            echo "  acquire <清单路径> <任务ID>    - 领取任务"
+            echo "  complete <清单路径> <任务ID> [结果] - 标记任务完成"
+            echo "  fail <清单路径> <任务ID> <错误> - 标记任务失败"
+            echo "  list <清单路径>               - 列出可用任务"
+            echo "  parallel <清单路径> [并行数]  - 并行执行任务"
+            echo "  check-deps <清单路径> <任务ID> - 检查任务依赖"
+            echo "  help                          - 显示帮助信息"
+            ;;
+    esac
+}
+
+# 如果是直接执行而不是被 source，则运行主函数
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+    main "$@"
+fi