ai-project-manage-cli 7.0.2 → 7.0.3

package/template/deploy/deploy.py

@@ -1,564 +0,0 @@
-#!/usr/bin/env python3
-"""自动部署脚本"""
-
-from __future__ import annotations
-
-import json
-import posixpath
-import re
-import shlex
-import shutil
-import subprocess
-import sys
-import time
-import zipfile
-from dataclasses import dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-import paramiko
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-PROJECT_ROOT = SCRIPT_DIR.parent.parent
-APM_CONFIG_PATH = PROJECT_ROOT / ".apm" / "apm.config.json"
-DEPLOY_CACHE_DIR = SCRIPT_DIR / ".deploy_cache"
-MANIFEST_FILE = DEPLOY_CACHE_DIR / "manifest.json"
-SPRINGBOOT_SCRIPT = "springboot.sh"
-MAVEN_MODULE = "jeecg-module-system/jeecg-system-start"
-MAVEN_PROFILE = "dev"
-
-if sys.platform == "win32" and hasattr(sys.stdout, "reconfigure"):
-    sys.stdout.reconfigure(encoding="utf-8")
-    sys.stderr.reconfigure(encoding="utf-8")
-
-
-def log(message: str) -> None:
-    print(f"[{datetime.now().strftime('%H:%M:%S')}] {message}")
-
-
-def fail(message: str, code: int = 1) -> None:
-    log(f"ERROR: {message}")
-    sys.exit(code)
-
-
-def expand_path(path_str: str) -> Path:
-    return Path(path_str).expanduser().resolve()
-
-
-def load_apm_config(apm_path: Path) -> dict[str, Any]:
-    with apm_path.open("r", encoding="utf-8") as handle:
-        data = json.load(handle)
-
-    name = str(data["name"]).strip()
-    deploy = data["wisdomDeploy"]
-    health = data["healthCheck"]
-
-    jar_path = str(deploy["jarPath"]).strip()
-    remote_app_dir = posixpath.dirname(jar_path)
-
-    return {
-        "project_name": name,
-        "host": deploy["host"],
-        "port": deploy["port"],
-        "username": deploy["username"],
-        "password": deploy["password"],
-        "remote_vue_dist_dir": str(deploy["remotePath"]).strip(),
-        "remote_app_dir": remote_app_dir,
-        "remote_lib_dir": posixpath.join(remote_app_dir, "lib"),
-        "startup_jar": posixpath.basename(jar_path),
-        "package_name": f"{name}.jar.zip",
-        "maven_local_repo": str(deploy["mavenLocalRepo"]).strip(),
-        "health_check_port": health["port"],
-        "health_check_context": health["context"],
-        "health_check_timeout": health["timeout"],
-    }
-
-
-def load_config() -> dict[str, Any]:
-    return load_apm_config(APM_CONFIG_PATH)
-
-
-def get_target_dir() -> Path:
-    return PROJECT_ROOT / MAVEN_MODULE / "target"
-
-
-def get_maven_local_repo(config: dict[str, Any]) -> Path:
-    return expand_path(str(config["maven_local_repo"]).strip())
-
-
-@dataclass
-class UpdateEntry:
-    path: Path
-    arcname: str
-    reason: str
-
-
-def relative_key(path: Path) -> str:
-    return path.resolve().relative_to(PROJECT_ROOT.resolve()).as_posix()
-
-
-def file_signature(path: Path) -> dict[str, float | int]:
-    stat = path.stat()
-    return {"size": int(stat.st_size), "mtime": float(stat.st_mtime)}
-
-
-def load_manifest() -> dict[str, dict[str, float | int]]:
-    if not MANIFEST_FILE.exists():
-        return {}
-    with MANIFEST_FILE.open("r", encoding="utf-8") as handle:
-        return json.load(handle)
-
-
-def save_manifest(manifest: dict[str, dict[str, float | int]]) -> None:
-    DEPLOY_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    with MANIFEST_FILE.open("w", encoding="utf-8") as handle:
-        json.dump(manifest, handle, ensure_ascii=False, indent=2)
-
-
-def is_project_lib_jar(jar_name: str) -> bool:
-    return jar_name.startswith("jeecg-")
-
-
-def list_lib_files_to_upload(
-    local_lib_dir: Path,
-    remote_stats: dict[str, paramiko.SFTPAttributes],
-    *,
-    manifest: dict[str, dict[str, float | int]] | None = None,
-) -> list[UpdateEntry]:
-    entries: list[UpdateEntry] = []
-    for jar_file in sorted(local_lib_dir.glob("*.jar")):
-        remote_attr = remote_stats.get(jar_file.name)
-        should_upload, reason = should_upload_lib_file(
-            jar_file,
-            remote_attr,
-            manifest,
-        )
-        if should_upload:
-            entries.append(
-                UpdateEntry(
-                    path=jar_file,
-                    arcname=jar_file.name,
-                    reason=reason,
-                )
-            )
-    return entries
-
-
-def create_update_package(entries: list[UpdateEntry], package_name: str) -> Path:
-    DEPLOY_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    zip_path = DEPLOY_CACHE_DIR / package_name
-
-    log(f"创建更新包: {zip_path.name}（{len(entries)} 个文件）")
-    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive:
-        for entry in entries:
-            archive.write(entry.path, arcname=entry.arcname)
-            log(f"  打包: {entry.arcname} ({entry.reason})")
-
-    return zip_path
-
-
-def upload_update_package(
-    sftp: paramiko.SFTPClient,
-    zip_path: Path,
-    config: dict[str, Any],
-) -> str:
-    remote_dir = config["remote_vue_dist_dir"]
-    remote_path = f"{remote_dir}/{zip_path.name}"
-
-    log(f"上传更新包 -> {remote_path}")
-
-    try:
-        sftp.put(str(zip_path), remote_path)
-        log("更新包上传成功")
-    except OSError as exc:
-        fail(f"更新包上传失败: {exc}")
-
-    return remote_path
-
-
-def update_manifest_entries(
-    manifest: dict[str, dict[str, float | int]],
-    entries: list[UpdateEntry],
-) -> dict[str, dict[str, float | int]]:
-    for entry in entries:
-        manifest[relative_key(entry.path)] = file_signature(entry.path)
-    return manifest
-
-
-def get_remote_file_stats(
-    sftp: paramiko.SFTPClient,
-    remote_dir: str,
-) -> dict[str, paramiko.SFTPAttributes]:
-    stats: dict[str, paramiko.SFTPAttributes] = {}
-    try:
-        for attr in sftp.listdir_attr(remote_dir):
-            if attr.filename.endswith(".jar"):
-                stats[attr.filename] = attr
-    except FileNotFoundError:
-        pass
-    return stats
-
-
-def should_upload_lib_file(
-    local_path: Path,
-    remote_attr: paramiko.SFTPAttributes | None,
-    manifest: dict[str, dict[str, float | int]] | None = None,
-) -> tuple[bool, str]:
-    if remote_attr is None:
-        return False, "远程不存在，跳过"
-
-    local_size = int(local_path.stat().st_size)
-    remote_size = int(remote_attr.st_size)
-    if local_size != remote_size:
-        return True, f"大小变化 {remote_size} -> {local_size}"
-
-    if is_project_lib_jar(local_path.name) and manifest is not None:
-        key = relative_key(local_path)
-        current = file_signature(local_path)
-        previous = manifest.get(key)
-        if previous is None:
-            return True, "项目模块未记录"
-        if int(previous["size"]) != current["size"]:
-            return True, "项目模块大小变化"
-        if float(previous["mtime"]) < current["mtime"]:
-            return True, "项目模块重新构建"
-
-    return False, "大小一致，跳过"
-
-
-def get_mvn_executable() -> str:
-    candidates = ("mvn.cmd", "mvn.bat", "mvn") if sys.platform == "win32" else ("mvn",)
-    for name in candidates:
-        found = shutil.which(name)
-        if found:
-            return found
-    fail("未找到 mvn 命令，请确认 Maven 已安装并加入 PATH")
-
-
-def run_maven_build(config: dict[str, Any]) -> None:
-    profile = MAVEN_PROFILE
-    maven_repo = get_maven_local_repo(config)
-    cmd = [
-        get_mvn_executable(),
-        "clean",
-        "package",
-        f"-P{profile}",
-        f"-Dmaven.repo.local={maven_repo}",
-        "-DskipTests",
-    ]
-
-    log(f"开始 Maven 构建: {' '.join(cmd)}")
-    log(f"Maven 本地仓库: {maven_repo}")
-    result = subprocess.run(
-        cmd,
-        cwd=PROJECT_ROOT,
-    )
-    if result.returncode != 0:
-        fail(f"Maven 构建失败，退出码: {result.returncode}")
-
-
-def locate_lib_dir() -> Path:
-    target_dir = get_target_dir()
-    if not target_dir.exists():
-        fail(f"构建产物目录不存在: {target_dir}")
-
-    lib_dir = target_dir / "lib"
-    if not lib_dir.is_dir():
-        fail(f"lib 目录不存在: {lib_dir}")
-
-    lib_jars = list(lib_dir.glob("*.jar"))
-    if not lib_jars:
-        fail(f"lib 目录下没有依赖 JAR: {lib_dir}")
-
-    log(f"定位 lib 产物: {len(lib_jars)} 个")
-    return lib_dir
-
-
-def connect_ssh(config: dict[str, Any]) -> paramiko.SSHClient:
-    client = paramiko.SSHClient()
-    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-    log(f"连接服务器 {config['username']}@{config['host']}:{config['port']}")
-    connect_kwargs: dict[str, Any] = {
-        "hostname": config["host"],
-        "port": int(config["port"]),
-        "username": config["username"],
-        "password": config["password"],
-        "timeout": 30,
-        "allow_agent": False,
-        "look_for_keys": False,
-    }
-
-    try:
-        client.connect(**connect_kwargs)
-    except Exception as exc:
-        fail(f"SSH 连接失败: {exc}")
-
-    return client
-
-
-def read_channel_stream(channel: paramiko.Channel) -> str:
-    """流式读取 SSH 通道输出，避免长时间命令无回显。"""
-    chunks: list[str] = []
-    while not channel.closed:
-        if channel.recv_ready():
-            data = channel.recv(4096)
-            if not data:
-                break
-            text = data.decode("utf-8", errors="replace")
-            chunks.append(text)
-            print(text, end="", flush=True)
-        elif channel.exit_status_ready():
-            while channel.recv_ready():
-                data = channel.recv(4096)
-                if data:
-                    text = data.decode("utf-8", errors="replace")
-                    chunks.append(text)
-                    print(text, end="", flush=True)
-            break
-        else:
-            time.sleep(0.2)
-
-    combined = "".join(chunks)
-    if combined and not combined.endswith("\n"):
-        print()
-    return combined.strip()
-
-
-def run_remote_command(
-    client: paramiko.SSHClient,
-    command: str,
-    *,
-    check: bool = True,
-    get_pty: bool = False,
-    stream: bool = False,
-    timeout_secs: float | None = None,
-) -> tuple[int, str, str]:
-    log(f"远程执行: {command}")
-    _, stdout, stderr = client.exec_command(command, get_pty=get_pty)
-    channel = stdout.channel
-    if timeout_secs is not None:
-        channel.settimeout(timeout_secs)
-
-    if stream:
-        out = read_channel_stream(channel)
-        err = ""
-    else:
-        out = stdout.read().decode("utf-8", errors="replace").strip()
-        err = "" if get_pty else stderr.read().decode("utf-8", errors="replace").strip()
-
-    exit_code = channel.recv_exit_status()
-
-    if not stream:
-        if out:
-            print(out)
-        if err:
-            print(err, file=sys.stderr)
-
-    if check and exit_code != 0:
-        fail(f"远程命令失败 (exit {exit_code}): {command}")
-
-    return exit_code, out, err
-
-
-def extract_update_package_on_remote(
-    client: paramiko.SSHClient,
-    config: dict[str, Any],
-    remote_zip_path: str,
-) -> int:
-    """解压更新包到 lib 目录，仅覆盖远程已存在的 JAR。"""
-    remote_lib_dir = config["remote_lib_dir"]
-    quoted_zip = shlex.quote(remote_zip_path)
-    quoted_lib = shlex.quote(remote_lib_dir)
-
-    script = f"""
-set -e
-TMP=$(mktemp -d)
-trap 'rm -rf "$TMP"' EXIT
-unzip -oq {quoted_zip} -d "$TMP"
-updated=0
-while IFS= read -r -d '' src; do
-  name=$(basename "$src")
-  dest={quoted_lib}/"$name"
-  if [ -f "$dest" ]; then
-    cp -f "$src" "$dest"
-    echo "覆盖: $name"
-    updated=$((updated + 1))
-  else
-    echo "跳过(远程不存在): $name"
-  fi
-done < <(find "$TMP" -name '*.jar' -type f -print0)
-echo "UPDATED_COUNT=$updated"
-"""
-
-    _, out, _ = run_remote_command(client, script)
-    match = re.search(r"UPDATED_COUNT=(\d+)", out)
-    if not match:
-        fail(f"远程解压失败，未获取更新数量\n输出: {out or '(空)'}")
-
-    updated = int(match.group(1))
-    log(f"lib 解压完成: 覆盖 {updated} 个")
-    return updated
-
-
-def springboot_output_indicates_success(action: str, combined: str) -> bool:
-    """springboot.sh 经 SSH 执行时 exit code 不可靠，需结合输出判断。"""
-    lower = combined.lower()
-    if action == "health":
-        return "健康检查通过" in combined
-    if action in {"start", "restart"}:
-        return "is starting" in combined or "is running" in lower
-    if action == "stop":
-        return (
-            "is stopping" in combined
-            or "not running" in lower
-            or "please check it" in lower
-        )
-    if action == "status":
-        return "running" in lower or "not running" in lower
-    return True
-
-
-def run_springboot_action(
-    client: paramiko.SSHClient,
-    config: dict[str, Any],
-    action: str,
-    *args: str,
-) -> str:
-    if action in {"start", "restart"}:
-        if not args:
-            fail(f"远程 {action} 缺少 jar 参数")
-        jar = args[0].strip().splitlines()[0].strip()
-        if not jar:
-            fail(f"无效的 jar 名称: {args[0]!r}")
-
-    command = " && ".join(
-        [
-            f"cd {shlex.quote(config['remote_app_dir'])}",
-            " ".join(
-                [f"./{SPRINGBOOT_SCRIPT}", *map(shlex.quote, (action, *args))]
-            ),
-        ]
-    )
-    exit_code, out, err = run_remote_command(
-        client,
-        command,
-        check=False,
-    )
-    combined = f"{out}\n{err}".strip()
-    output_ok = springboot_output_indicates_success(action, combined)
-    if action == "health":
-        if exit_code != 0 or not output_ok:
-            fail(
-                f"健康检查失败\n"
-                f"命令: {command}\n输出: {combined or '(空)'}"
-            )
-        return combined
-    if exit_code != 0 and not output_ok:
-        fail(f"远程 {action} 失败: {' '.join(args)}\n{combined}")
-    if action in {"start", "restart"} and not output_ok:
-        fail(
-            f"远程 {action} 未成功: {' '.join(args)}\n"
-            f"命令: {command}\n输出: {combined or '(空)'}"
-        )
-    return combined
-
-
-def get_running_jar(
-    client: paramiko.SSHClient,
-    app_dir: str,
-    config: dict[str, Any],
-) -> str | None:
-    combined = run_springboot_action(
-        client, config, "status", config["startup_jar"]
-    )
-    text = re.sub(r"\x1b\[[0-?]*[ -/]*[@-~]", "", combined).strip().lower()
-    if "not running" in text:
-        return None
-    if "running" in text:
-        return config["startup_jar"]
-    return None
-
-
-def health_check_service(
-    client: paramiko.SSHClient,
-    config: dict[str, Any],
-) -> None:
-    port = str(int(config["health_check_port"]))
-    context = str(config["health_check_context"]).strip()
-    timeout = str(int(config["health_check_timeout"]))
-    log(f"健康检查: springboot.sh health {port} {context} {timeout}")
-    run_springboot_action(client, config, "health", port, context, timeout)
-
-
-def main() -> None:
-    config = load_config()
-
-    log(f"=== 自动部署: {config['project_name']} ===")
-    log(f"配置文件: {APM_CONFIG_PATH}")
-    log(f"项目根目录: {PROJECT_ROOT}")
-
-    run_maven_build(config)
-
-    lib_dir = locate_lib_dir()
-    manifest = load_manifest()
-
-    client = connect_ssh(config)
-    need_restart = False
-    lib_upload_entries: list[UpdateEntry] = []
-    try:
-        sftp = client.open_sftp()
-        try:
-            app_dir = config["remote_app_dir"]
-            remote_lib_stats = get_remote_file_stats(sftp, config["remote_lib_dir"])
-
-            log("收集 JAR 更新...")
-            lib_upload_entries = list_lib_files_to_upload(
-                lib_dir,
-                remote_lib_stats,
-                manifest=manifest,
-            )
-
-            updated = 0
-            if lib_upload_entries:
-                zip_path = create_update_package(
-                    lib_upload_entries,
-                    config["package_name"],
-                )
-                remote_zip_path = upload_update_package(sftp, zip_path, config)
-                log("远程解压 lib 目录（仅覆盖已有 JAR）...")
-                updated = extract_update_package_on_remote(
-                    client,
-                    config,
-                    remote_zip_path,
-                )
-            else:
-                log("无 JAR 需要更新，跳过更新包上传")
-
-            running_jar = get_running_jar(client, app_dir, config)
-            need_restart = updated > 0
-            if not need_restart and not running_jar:
-                log("服务未运行，需要启动")
-                need_restart = True
-            elif not need_restart:
-                log("没有文件需要更新，跳过重启")
-
-            if need_restart:
-                log("重启服务...")
-                run_springboot_action(client, config, "restart", config["startup_jar"])
-
-            health_check_service(client, config)
-
-            if lib_upload_entries:
-                save_manifest(update_manifest_entries(manifest, lib_upload_entries))
-        finally:
-            sftp.close()
-    finally:
-        client.close()
-
-    log("部署完成")
-
-
-if __name__ == "__main__":
-    main()

package/template/skills/apm-apply-change/SKILL.md

@@ -1,114 +0,0 @@
-## 文档说明
-
-按工作项中的 **`plans/tasks.md`** 驱动实现：**读规划 → 写代码 → 对账元数据 → 勾选 → 单独 commit**，直至全部完成、**停止执行**或硬阻塞。
-
-**工作项根目录**：`.apm/project/`（下文路径均相对该目录）
-
-| 文件              | 路径                | 用途                                                                                      |
-| ----------------- | ------------------- | ----------------------------------------------------------------------------------------- |
-| tasks（**驱动**） | `plans/tasks.md`    | 唯一进度来源（`- [ ]` / `- [x]`）；缺文件、无待办 → 阻塞，须先 **apm-propose** 或手工补齐 |
-| PRD               | `docs/PRD.md`       | 范围与验收                                                                                |
-| proposal          | `plans/proposal.md` | 变更背景（按需）                                                                          |
-| design            | `plans/design.md`   | **改哪里**、技术决策（按任务引用）                                                        |
-| specs             | `plans/specs/*.md`  | **做什么**（按任务 **需求编号** 引用）                                                    |
-
-**前置**：`plans/tasks.md` 须由 **apm-propose** 生成，格式见 `.apm/skills/apm-propose/tasks.md`（`- [ ]`、元数据子列表等）。
-
-**单任务循环**：说明当前项 → 最小实现 → 对账（需求编号 / 预期与实际路径 / 完成标准）→ `- [x]` → **一项待办 = 一个 commit**。
-
----
-
-## 停止执行（优先于继续推进）
-
-发现规划与代码**严重不一致**、需用户做产品/架构**决策**、或环境/权限等**硬阻塞**时：**不再**处理下一项、**不**勾选完成，仅输出：
-
-1. **客观事实**：已读路径、与任务/代码的**具体矛盾**（可摘引）。
-2. **当前进度**：`plans/tasks.md` 处理到哪一条；未提交改动范围（若有）。
-3. **需要用户提供什么**：清单，一句一项。
-
-**禁止**：替用户决策、给「建议先改 A/B」、可选方案、排障命令（除非任务/文档已写明须执行的命令）。
-
-**允许**：说明「缺某信息则无法继续」的逻辑关系（不展开成方案）。
-
-**仍可继续**：任务略含糊，但在 PRD / design / specs / tasks 已有文字内可**自洽**完成；若有**假设**须写清。一旦假设触及「以谁为准」→ 转 **停止执行**。
-
----
-
-## 工作流程
-
-### 步骤 1：读取 `plans/tasks.md` 并判断状态
-
-1. **Read** `plans/tasks.md`。
-2. 缺失、为空或无 `- [ ]` → **停止**，提示先具备可执行 tasks。
-3. 若全部为 `- [x]` → 仅陈述「已全部完成」（不建议是否提交/MR）。
-
-### 步骤 2：读取实现上下文
-
-开始**第一个**未勾选任务前，至少 **Read** `docs/PRD.md` 及当前项所需的 `plans/design.md` / `plans/specs/` 片段（见任务 **需求编号**）。不要求每项任务重读全部规划；以**当前任务行** + 缺口再 Read 为准。
-
-#### 单轮读取策略
-
-| 文件                               | 建议                                                                             |
-| ---------------------------------- | -------------------------------------------------------------------------------- |
-| `docs/PRD.md`                      | 本轮首次实现前至少读一次                                                           |
-| `plans/design.md` / `plans/specs/` | 连续多项时，已读过且无疑虑可不重复全文；按任务元数据 **Read（偏移）** 或再读全文 |
-
-### 步骤 3：展示进度并开始循环
-
-展示 **N/M 已完成**（由勾选统计）、**当前将处理**的下一条 `- [ ]`（含编号如 `2.1`）。
-
-对每条未勾选任务（建议自上而下）：
-
-1. 说明正在处理的编号与简述。
-2. **最小**改动实现；与该项描述一致。
-3. **勾选前**对账（与 `plans/tasks.md` 子列表字段一致）：
-   - **需求编号**、**预期改动路径** vs **实际改动文件**（偏差须简述）
-   - **验证用例编号**（若有）、**完成标准** / 验证结果
-4. 依据齐且自洽后，将对应行改为 `- [x]`，**立即**单独 `git commit`（信息含任务编号或简述）。
-
-### 步骤 4：收尾
-
-- **全部完成**：进度 N/M、本轮已完成项摘要；**不**建议 MR/发布等后续流程。
-- **暂停**：按 **停止执行** 三节输出；无「可选后续」。
-
----
-
-## 输出示例
-
-**进行中**
-
-```
-## 正在实施
-
-处理任务 3/7：2.1 实现导出接口
-✓ 任务完成 · commit <short-sha> <subject>
-```
-
-**全部完成**
-
-```
-## 实现完成
-**进度：** 7/7 ✓
-（每项待办均已对应独立 commit。）
-```
-
-**暂停**
-
-```
-## 实现已暂停
-**进度：** 4/7
-### 事实与原因
-…
-### 需要用户提供（或决策）
-- …
-```
-
----
-
-## Guardrails
-
-- 持续执行待办，直至完成、**停止执行**或硬阻塞。
-- 未读清当前任务依赖前**不要**盲改；未对账前**不要**勾选完成。
-- 验证失败或依据不足时保持 `- [ ]` 并写明缺口；元数据缺失时在实现前尽量补全或按 tasks 模板推断并注明。
-- **不要**因发现规划与代码不符而主动改 `plans/` 下规划文件或建议改哪份；**停止**并交还用户。
-- **可分段调用**：部分完成后结束本轮，下次同一工作项继续；规划修订由用户在流程外完成后再运行本技能。

package/template/skills/apm-deploy/SKILL.md

@@ -1,10 +0,0 @@
-## 工作流程
-
-### 步骤1: 阅读部署文档  
-使用**Read**工具阅读 `.apm/deploy/README.md`
-
-### 步骤2: 按照文档执行部署命令，禁止猜测参数
-
-如果遇到以下情况则无需部署，直接退出部署流程
-1. 没有找到部署文档，或者部署文档没有可执行的部署命令（或者说部署不可执行）
-2. 用户没有明确部署环境