@huajiwuyan/hello 3.0.0

package/templates/codex/skills/rlm/shared_tasks.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+HelloAGENTS-RLM Shared Tasks Manager
+多终端协作任务管理器
+
+核心设计:
+- 默认隔离模式: 每个终端独立任务列表
+- 协作模式: 通过环境变量指定共享任务列表 ID
+- 支持任务依赖: blocks/blocked_by 自动管理
+- 文件锁保护并发写入
+"""
+
+import fcntl
+import json
+import os
+import platform
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class SharedTasksManager:
+    """
+    多终端协作任务管理器
+
+    使用方式:
+      隔离模式（默认）: 直接运行 AI CLI
+      协作模式: hellotasks=<任务列表ID> <AI CLI 命令>
+
+    支持的 AI CLI:
+      - Codex CLI: hellotasks=auth-migration codex
+      - Claude Code: hellotasks=auth-migration claude
+
+    任务存储位置:
+      协作模式: {项目目录}/helloagents/tasks/{list_id}.json
+      隔离模式: 由 session.py 管理
+    """
+
+    def __init__(self, project_root: Optional[Path] = None):
+        """
+        初始化任务管理器
+
+        Args:
+            project_root: 项目根目录，默认为当前工作目录
+        """
+        self.project_root = project_root or Path.cwd()
+        self.tasks_dir = self.project_root / "helloagents" / "tasks"
+
+        # 从环境变量获取任务列表 ID
+        self.list_id = os.environ.get("hellotasks")
+        self.is_collaborative = bool(self.list_id)
+
+        if self.is_collaborative:
+            self.tasks_dir.mkdir(parents=True, exist_ok=True)
+            self.tasks_file = self.tasks_dir / f"{self.list_id}.json"
+            self._init_task_list()
+
+    def _init_task_list(self):
+        """初始化任务列表文件"""
+        if not self.tasks_file.exists():
+            initial_data = {
+                "list_id": self.list_id,
+                "created_at": datetime.now().isoformat(),
+                "last_updated": datetime.now().isoformat(),
+                "tasks": [],
+            }
+            self._write_tasks(initial_data)
+
+    # ==================== 文件锁操作 ====================
+
+    def _read_tasks(self) -> Dict[str, Any]:
+        """读取任务列表（带共享锁）"""
+        if not self.is_collaborative:
+            return {"tasks": []}
+
+        if not self.tasks_file.exists():
+            return {"list_id": self.list_id, "tasks": []}
+
+        try:
+            with open(self.tasks_file, 'r', encoding='utf-8') as f:
+                # Windows 不支持 fcntl，使用替代方案
+                if platform.system() != 'Windows':
+                    fcntl.flock(f.fileno(), fcntl.LOCK_SH)
+                try:
+                    return json.load(f)
+                finally:
+                    if platform.system() != 'Windows':
+                        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+        except Exception:
+            return {"list_id": self.list_id, "tasks": []}
+
+    def _write_tasks(self, data: Dict[str, Any]) -> bool:
+        """写入任务列表（带排他锁）"""
+        if not self.is_collaborative:
+            return False
+
+        data["last_updated"] = datetime.now().isoformat()
+
+        try:
+            with open(self.tasks_file, 'w', encoding='utf-8') as f:
+                # Windows 使用简单的文件写入
+                if platform.system() != 'Windows':
+                    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                try:
+                    json.dump(data, f, ensure_ascii=False, indent=2)
+                    return True
+                finally:
+                    if platform.system() != 'Windows':
+                        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+        except Exception:
+            return False
+
+    # ==================== 任务 CRUD ====================
+
+    def add_task(
+        self,
+        subject: str,
+        description: str = "",
+        blocks: Optional[List[str]] = None,
+        blocked_by: Optional[List[str]] = None,
+    ) -> Optional[str]:
+        """
+        添加任务
+
+        Args:
+            subject: 任务标题
+            description: 任务描述
+            blocks: 此任务完成后解锁的任务 ID 列表
+            blocked_by: 阻塞此任务的任务 ID 列表
+
+        Returns:
+            任务 ID，失败返回 None
+        """
+        if not self.is_collaborative:
+            return None
+
+        data = self._read_tasks()
+        task_id = f"t{len(data['tasks']) + 1}_{datetime.now().strftime('%H%M%S')}"
+
+        task = {
+            "id": task_id,
+            "subject": subject,
+            "description": description,
+            "status": "pending",
+            "owner": None,
+            "blocks": blocks or [],
+            "blocked_by": blocked_by or [],
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+        }
+
+        data["tasks"].append(task)
+        if self._write_tasks(data):
+            return task_id
+        return None
+
+    def update_task(
+        self,
+        task_id: str,
+        status: Optional[str] = None,
+        owner: Optional[str] = None,
+    ) -> bool:
+        """
+        更新任务状态
+
+        Args:
+            task_id: 任务 ID
+            status: 新状态 (pending/in_progress/completed)
+            owner: 任务负责人（终端标识）
+
+        Returns:
+            是否成功
+        """
+        if not self.is_collaborative:
+            return False
+
+        data = self._read_tasks()
+
+        for task in data["tasks"]:
+            if task["id"] == task_id:
+                if status:
+                    task["status"] = status
+                if owner is not None:
+                    task["owner"] = owner
+                task["updated_at"] = datetime.now().isoformat()
+
+                # 如果任务完成，自动更新依赖关系
+                if status == "completed":
+                    self._resolve_dependencies(data, task_id)
+
+                return self._write_tasks(data)
+
+        return False
+
+    def _resolve_dependencies(self, data: Dict[str, Any], completed_task_id: str):
+        """解除依赖：将 completed_task_id 从其他任务的 blocked_by 中移除"""
+        for task in data["tasks"]:
+            if completed_task_id in task.get("blocked_by", []):
+                task["blocked_by"].remove(completed_task_id)
+                task["updated_at"] = datetime.now().isoformat()
+
+    def claim_task(self, task_id: str, owner: str) -> bool:
+        """
+        认领任务
+
+        Args:
+            task_id: 任务 ID
+            owner: 认领者标识
+
+        Returns:
+            是否成功（已被他人认领则失败）
+        """
+        if not self.is_collaborative:
+            return False
+
+        data = self._read_tasks()
+
+        for task in data["tasks"]:
+            if task["id"] == task_id:
+                # 检查是否已被认领
+                if task["owner"] and task["owner"] != owner:
+                    return False  # 已被他人认领
+
+                # 检查是否被阻塞
+                if task.get("blocked_by"):
+                    return False  # 还有未完成的依赖
+
+                task["owner"] = owner
+                task["status"] = "in_progress"
+                task["updated_at"] = datetime.now().isoformat()
+                return self._write_tasks(data)
+
+        return False
+
+    def get_available_tasks(self) -> List[Dict[str, Any]]:
+        """获取可认领的任务（无阻塞、未被认领）"""
+        if not self.is_collaborative:
+            return []
+
+        data = self._read_tasks()
+        available = []
+
+        for task in data["tasks"]:
+            if (task["status"] == "pending" and
+                not task.get("owner") and
+                not task.get("blocked_by")):
+                available.append(task)
+
+        return available
+
+    def get_task_list(self) -> List[Dict[str, Any]]:
+        """获取完整任务列表"""
+        if not self.is_collaborative:
+            return []
+
+        data = self._read_tasks()
+        return data.get("tasks", [])
+
+    def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:
+        """获取单个任务详情"""
+        if not self.is_collaborative:
+            return None
+
+        data = self._read_tasks()
+        for task in data["tasks"]:
+            if task["id"] == task_id:
+                return task
+        return None
+
+    # ==================== 状态查询 ====================
+
+    def get_status(self) -> Dict[str, Any]:
+        """获取任务列表状态"""
+        if not self.is_collaborative:
+            return {
+                "mode": "isolated",
+                "message": "未指定共享任务列表，使用隔离模式",
+            }
+
+        data = self._read_tasks()
+        tasks = data.get("tasks", [])
+
+        pending = sum(1 for t in tasks if t["status"] == "pending")
+        in_progress = sum(1 for t in tasks if t["status"] == "in_progress")
+        completed = sum(1 for t in tasks if t["status"] == "completed")
+        blocked = sum(1 for t in tasks if t.get("blocked_by"))
+
+        return {
+            "mode": "collaborative",
+            "list_id": self.list_id,
+            "tasks_file": str(self.tasks_file),
+            "total": len(tasks),
+            "pending": pending,
+            "in_progress": in_progress,
+            "completed": completed,
+            "blocked": blocked,
+            "last_updated": data.get("last_updated"),
+        }
+
+    def refresh(self) -> List[Dict[str, Any]]:
+        """
+        强制刷新任务列表（从文件重新读取）
+
+        用于检查其他终端的更新
+        """
+        return self.get_task_list()
+
+
+# ==================== 便捷函数 ====================
+
+def get_task_manager(project_root: Optional[str] = None) -> SharedTasksManager:
+    """获取任务管理器实例"""
+    return SharedTasksManager(
+        project_root=Path(project_root) if project_root else None
+    )
+
+
+def is_collaborative_mode() -> bool:
+    """检查是否为协作模式"""
+    return bool(os.environ.get("hellotasks"))
+
+
+# ==================== CLI 入口 ====================
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="HelloAGENTS Shared Tasks Manager")
+    parser.add_argument("--status", action="store_true", help="显示任务列表状态")
+    parser.add_argument("--list", action="store_true", help="列出所有任务")
+    parser.add_argument("--available", action="store_true", help="列出可认领的任务")
+    parser.add_argument("--add", type=str, help="添加任务 (subject)")
+    parser.add_argument("--complete", type=str, help="标记任务完成 (task_id)")
+    parser.add_argument("--claim", type=str, help="认领任务 (task_id)")
+    parser.add_argument("--owner", type=str, default="cli", help="认领者标识")
+
+    args = parser.parse_args()
+    manager = SharedTasksManager()
+
+    if args.status:
+        print(json.dumps(manager.get_status(), ensure_ascii=False, indent=2))
+
+    elif args.list:
+        tasks = manager.get_task_list()
+        print(json.dumps(tasks, ensure_ascii=False, indent=2))
+
+    elif args.available:
+        tasks = manager.get_available_tasks()
+        print(json.dumps(tasks, ensure_ascii=False, indent=2))
+
+    elif args.add:
+        task_id = manager.add_task(subject=args.add)
+        if task_id:
+            print(json.dumps({"success": True, "task_id": task_id}, ensure_ascii=False))
+        else:
+            print(json.dumps({"success": False, "error": "添加失败或非协作模式"}, ensure_ascii=False))
+
+    elif args.complete:
+        success = manager.update_task(args.complete, status="completed")
+        print(json.dumps({"success": success}, ensure_ascii=False))
+
+    elif args.claim:
+        success = manager.claim_task(args.claim, owner=args.owner)
+        print(json.dumps({"success": success}, ensure_ascii=False))
+
+    else:
+        # 默认显示状态
+        print(json.dumps(manager.get_status(), ensure_ascii=False, indent=2))

package/templates/codex/skills/scripts/create_package.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+创建 HelloAGENTS 方案包
+
+Usage:
+    python create_package.py <feature-name> [--path <base-path>] [--type <implementation|overview>]
+
+Examples:
+    python create_package.py user-login
+    python create_package.py api-refactor --type overview
+    python create_package.py auth-system --path /path/to/project
+"""
+
+import argparse
+import re
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# 确保能找到同目录下的 utils 模块
+sys.path.insert(0, str(Path(__file__).parent))
+from utils import (
+    setup_encoding,
+    get_plan_path,
+    generate_package_name,
+    print_error,
+    print_success,
+    validate_base_path,
+    get_template_loader,
+    ExecutionReport
+)
+
+
+# 模板路径常量
+TEMPLATE_PROPOSAL = "plan/proposal.md"
+TEMPLATE_TASKS = "plan/tasks.md"
+
+
+def create_package(feature: str, base_path: str = None, pkg_type: str = "implementation") -> ExecutionReport:
+    """
+    创建方案包（并发安全，支持 AI 降级接手）
+
+    Args:
+        feature: 功能名称
+        base_path: 项目根目录
+        pkg_type: 方案包类型 (implementation/overview)
+
+    Returns:
+        ExecutionReport: 执行报告，包含完成状态和上下文
+    """
+    report = ExecutionReport("create_package")
+    report.set_context(feature=feature, pkg_type=pkg_type, base_path=base_path or "cwd")
+
+    plan_path = get_plan_path(base_path)
+    original_name = generate_package_name(feature)
+
+    # 步骤1: 确保父目录存在
+    try:
+        plan_path.mkdir(parents=True, exist_ok=True)
+        report.mark_completed(
+            "创建 plan/ 目录",
+            str(plan_path),
+            "检查目录是否存在: ls 或 Read 工具"
+        )
+    except PermissionError as e:
+        report.mark_failed(
+            "创建 plan/ 目录",
+            ["创建 plan/ 目录", "创建方案包目录", "创建 proposal.md", "创建 tasks.md"],
+            f"权限不足: {e}"
+        )
+        return report
+
+    # 步骤2: 并发安全的目录创建（原子操作 + 重试）
+    max_retries = 100
+    package_path = None
+    package_name = None
+
+    for version in range(1, max_retries + 1):
+        package_name = original_name if version == 1 else f"{original_name}_v{version}"
+        package_path = plan_path / package_name
+
+        try:
+            package_path.mkdir(exist_ok=False)
+            report.mark_completed(
+                "创建方案包目录",
+                str(package_path),
+                "检查目录是否存在且为空目录"
+            )
+            report.set_context(package_path=str(package_path), package_name=package_name)
+            break
+        except FileExistsError:
+            continue
+        except PermissionError as e:
+            report.mark_failed(
+                "创建方案包目录",
+                ["创建方案包目录", "创建 proposal.md", "创建 tasks.md"],
+                f"权限不足: {package_path}"
+            )
+            return report
+    else:
+        report.mark_failed(
+            "创建方案包目录",
+            ["创建方案包目录", "创建 proposal.md", "创建 tasks.md"],
+            f"超过最大重试次数 ({max_retries})，存在大量同名方案包"
+        )
+        return report
+
+    # 步骤3: 加载并填充模板
+    current_date = datetime.now().strftime("%Y-%m-%d")
+    loader = get_template_loader()
+
+    # 定义占位符替换映射
+    replacements = {
+        "{feature}": feature,
+        "{YYYY-MM-DD}": current_date,
+        "{pkg_type}": pkg_type,
+        "{package_name}": package_name,
+        "{YYYYMMDDHHMM}_{feature}": package_name
+    }
+
+    # 步骤4: proposal.md - 检查模板存在性
+    proposal_content = loader.fill(TEMPLATE_PROPOSAL, replacements)
+    if proposal_content is None:
+        report.mark_failed(
+            f"加载模板 {TEMPLATE_PROPOSAL}",
+            ["创建 proposal.md（需包含：元信息、需求、方案章节）", "创建 tasks.md"],
+            f"模板文件不存在: {TEMPLATE_PROPOSAL}"
+        )
+        return report
+
+    # 步骤5: tasks.md - 检查模板存在性
+    tasks_content = loader.fill(TEMPLATE_TASKS, replacements)
+    if tasks_content is None:
+        report.mark_failed(
+            f"加载模板 {TEMPLATE_TASKS}",
+            ["创建 tasks.md（需包含：执行状态、任务列表、执行备注章节）"],
+            f"模板文件不存在: {TEMPLATE_TASKS}"
+        )
+        # 仍需标记 proposal 模板加载成功
+        report.mark_completed(
+            "加载 proposal.md 模板",
+            "模板内容已加载",
+            "N/A - 模板加载成功但未写入文件"
+        )
+        return report
+
+    # overview 类型：替换任务列表为"无执行任务"
+    if pkg_type == "overview":
+        # 替换执行状态中的完成率
+        tasks_content = re.sub(r'完成率:\s*\d+%', '完成率: N/A', tasks_content)
+        tasks_content = re.sub(r'总任务:\s*\w+', '总任务: 0', tasks_content)
+        # 替换任务列表部分
+        tasks_content = re.sub(
+            r'## 任务列表\s*\n.*?(?=\n---)',
+            '## 任务列表\n\n> 无执行任务（概述文档）\n',
+            tasks_content,
+            flags=re.DOTALL
+        )
+
+    # 步骤6: 写入 proposal.md
+    proposal_path = package_path / "proposal.md"
+    try:
+        proposal_path.write_text(proposal_content, encoding='utf-8')
+        report.mark_completed(
+            "创建 proposal.md",
+            str(proposal_path),
+            "检查文件存在且包含必需章节（元信息、需求、方案）"
+        )
+    except Exception as e:
+        report.mark_failed(
+            "写入 proposal.md",
+            ["创建 proposal.md", "创建 tasks.md"],
+            str(e)
+        )
+        return report
+
+    # 步骤7: 写入 tasks.md
+    tasks_path = package_path / "tasks.md"
+    try:
+        tasks_path.write_text(tasks_content, encoding='utf-8')
+        report.mark_completed(
+            "创建 tasks.md",
+            str(tasks_path),
+            "检查文件存在且包含必需章节（执行状态、任务列表）"
+        )
+    except Exception as e:
+        report.mark_failed(
+            "写入 tasks.md",
+            ["创建 tasks.md"],
+            str(e)
+        )
+        return report
+
+    # 全部完成
+    report.mark_success(str(package_path))
+    return report
+
+
+def main():
+    setup_encoding()
+    parser = argparse.ArgumentParser(
+        description="创建 HelloAGENTS 方案包"
+    )
+    parser.add_argument(
+        "feature",
+        help="功能名称 (如: user-login, api-refactor)"
+    )
+    parser.add_argument(
+        "--path",
+        default=None,
+        help="项目根目录 (默认: 当前目录)"
+    )
+    parser.add_argument(
+        "--type",
+        choices=["implementation", "overview"],
+        default="implementation",
+        help="方案包类型: implementation(实施计划) 或 overview(概述文档)"
+    )
+
+    args = parser.parse_args()
+
+    # 验证基础路径
+    try:
+        validate_base_path(args.path)
+    except ValueError as e:
+        report = ExecutionReport("create_package")
+        report.mark_failed("验证基础路径", ["验证路径", "创建方案包"], str(e))
+        report.print_report()
+        sys.exit(1)
+
+    # 验证 feature 名称
+    feature = args.feature.strip()
+    if not feature:
+        report = ExecutionReport("create_package")
+        report.mark_failed("验证功能名称", ["创建方案包"], "功能名称不能为空")
+        report.print_report()
+        sys.exit(1)
+
+    # 预验证 feature 名称有效性（检查规范化后是否为空）
+    try:
+        generate_package_name(feature)
+    except ValueError as e:
+        report = ExecutionReport("create_package")
+        report.mark_failed("验证功能名称", ["创建方案包"], str(e))
+        report.print_report()
+        sys.exit(1)
+
+    # 执行创建
+    report = create_package(feature, args.path, args.type)
+
+    # 输出执行报告（JSON格式，供 AI 解析）
+    report.print_report()
+
+    # 返回状态码
+    sys.exit(0 if report.success else 1)
+
+
+if __name__ == "__main__":
+    main()