@jspg-ai/coding-bb 0.0.1

package/cbb/tools/cbb-mvn-guide/scripts/mvn_jdk_manager.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""
+jdk_manager.py — 跨平台迷你 JDK 版本管理器(纯标准库)。
+
+供 cbb-mvn-guide skill 使用,替代 jabba,避免外部下载依赖。
+注册表存 ~/.jdk-registry.json,记录已登记的 JDK。
+
+子命令:
+    ls                              列出已登记的 JDK(名 -> 路径 -> 主版本)
+    current                         显示当前 JAVA_HOME 指向的 JDK
+    link <name> <jdk_home>          登记一个本机已装的 JDK(校验 bin/java 存在)
+    unlink <name>                   移除登记
+    use <name>                      输出当前 shell 的 env 设置语句(不直接 set,
+                                    由调用方在同一条 shell 命令里 eval/source)
+    scan [--adopt]                  扫描常见目录列出已装 JDK;
+                                    --adopt 一键登记未登记的(显式触发,打印明细)
+    doctor [--prune]                检查注册表中路径是否仍有效;
+                                    --prune 清理失效登记
+    --shell <posix|powershell>      指定 use 输出格式;不指定则按平台自动判断
+
+用法示例(POSIX):
+    python jdk_manager.py link corretto8 /Library/Java/JavaVirtualMachines/corretto-8/Contents/Home
+    eval "$(python jdk_manager.py use corretto8)"; mvn -v
+
+用法示例(PowerShell):
+    python jdk_manager.py link corretto8 D:\\env\\jdk\\corretto-1.8
+    python jdk_manager.py use corretto8 | Invoke-Expression; mvn -v
+
+归一化主版本号(供 ls 展示与匹配): 1.8 -> 8, 21 -> 21。
+"""
+
+# 抑制字节码缓存:本脚本作为工具直接调用、无复用价值,避免在 scripts/ 下生成 __pycache__/
+import sys
+if not getattr(sys, 'dont_write_bytecode', False):
+    sys.dont_write_bytecode = True
+
+import argparse
+import glob
+import json
+import os
+import platform
+import re
+import subprocess
+from pathlib import Path
+
+# 强制 stdout/stderr 用 UTF-8,避免 Windows 控制台(GBK)中文乱码
+try:
+    sys.stdout.reconfigure(encoding="utf-8")
+    sys.stderr.reconfigure(encoding="utf-8")
+except Exception:
+    pass
+
+REGISTRY_PATH = Path.home() / ".jdk-registry.json"
+QUIET = False
+
+# 扫描目录(按平台)。glob 模式,匹配到的目录若含 bin/java 则视为 JDK。
+SCAN_PATTERNS_WIN = [
+    r"C:\Program Files\Java\*",
+    r"C:\Program Files\Eclipse Adoptium\*",
+    r"C:\Program Files\Amazon Corretto\*",
+    r"C:\Program Files\Zulu\*",
+    r"C:\Program Files\Microsoft\jdk\*",
+    r"D:\env\jdk\*",
+    r"D:\env\*\jdk*",
+    r"D:\Program Files\Java\*",
+]
+SCAN_PATTERNS_POSIX = [
+    "/Library/Java/JavaVirtualMachines/*/Contents/Home",
+    "/usr/lib/jvm/*",
+    os.path.expanduser("~/.sdkman/candidates/java/*"),
+    os.path.expanduser("~/.jdks/*"),
+    "/opt/homebrew/opt/openjdk*/libexec/openjdk.jdk/Contents/Home",
+]
+
+# vendor 关键词(小写匹配),用于自动命名;顺序即优先级。
+VENDOR_KEYWORDS = [
+    "corretto",
+    "temurin",
+    "adoptium",
+    "adoptopenjdk",
+    "zulu",
+    "graalvm",
+    "oracle",
+    "liberica",
+    "microsoft",
+    "openjdk",
+]
+
+
+def fail(msg):
+    """失败退出。quiet 模式下静默退出(不打印 stderr),由调用方靠退出码判断后自行提示用户。"""
+    if not QUIET:
+        print(msg, file=sys.stderr)
+    sys.exit(1)
+
+
+def normalize_major(raw):
+    """版本字符串归一化主版本号:1.8.0_492->8, 21.0.10->21;无法解析返回 None。"""
+    if not raw:
+        return None
+    m = re.match(r"^1\.(\d+)", raw)
+    if m:
+        return m.group(1)
+    m = re.match(r"^(\d+)", raw)
+    if m:
+        return m.group(1)
+    return None
+
+
+def java_bin_name():
+    return "java.exe" if platform.system() == "Windows" else "java"
+
+
+def is_valid_jdk_home(home):
+    """校验 home 下存在 bin/java(.exe)。"""
+    return (Path(home) / "bin" / java_bin_name()).is_file()
+
+
+def detect_version_string(home):
+    """跑 bin/java -version 拿原始版本字符串(如 21.0.10 / 1.8.0_492),失败返回 None。"""
+    exe = str(Path(home) / "bin" / java_bin_name())
+    try:
+        out = subprocess.run(
+            [exe, "-version"],
+            capture_output=True, text=True, timeout=15,
+        )
+        text = (out.stderr or "") + (out.stdout or "")
+    except Exception:
+        return None
+    m = re.search(r'version "([^"]+)"', text)
+    return m.group(1) if m else None
+
+
+def detect_major(home):
+    """跑 bin/java -version 拿主版本号,失败返回 None。"""
+    raw = detect_version_string(home)
+    return normalize_major(raw) if raw else None
+
+
+def detect_vendor(home):
+    """从路径关键词推断 vendor,用于自动命名(仅参考,不强求准确)。"""
+    h = str(home).lower()
+    for v in VENDOR_KEYWORDS:
+        if v in h:
+            # adoptium/adoptopenjdk 统一归到 temurin 命名
+            return "temurin" if v in ("adoptium", "adoptopenjdk") else v
+    return "jdk"
+
+
+def load_registry():
+    if not REGISTRY_PATH.is_file():
+        return {}
+    try:
+        with REGISTRY_PATH.open("r", encoding="utf-8") as f:
+            return json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def save_registry(reg):
+    try:
+        with REGISTRY_PATH.open("w", encoding="utf-8") as f:
+            json.dump(reg, f, ensure_ascii=False, indent=2)
+    except OSError as e:
+        fail(f"写注册表失败: {e}")
+
+
+def unique_name(base_name, existing_names):
+    """生成不冲突的登记名:base_name 被占用则加 _2/_3..."""
+    if base_name not in existing_names:
+        return base_name
+    i = 2
+    while f"{base_name}_{i}" in existing_names:
+        i += 1
+    return f"{base_name}_{i}"
+
+
+def scan_patterns():
+    return SCAN_PATTERNS_WIN if platform.system() == "Windows" else SCAN_PATTERNS_POSIX
+
+
+def find_installed_jdks():
+    """扫描常见目录,返回 [(abs_home, major, vendor), ...],去重并按路径排序。"""
+    seen = set()
+    found = []
+    for pattern in scan_patterns():
+        for cand in glob.glob(pattern):
+            cand = os.path.abspath(cand)
+            if cand in seen:
+                continue
+            if not os.path.isdir(cand):
+                continue
+            if not is_valid_jdk_home(cand):
+                continue
+            seen.add(cand)
+            major = detect_major(cand) or "?"
+            vendor = detect_vendor(cand)
+            found.append((cand, major, vendor))
+    found.sort(key=lambda x: x[0])
+    return found
+
+
+def cmd_ls(_args):
+    reg = load_registry()
+    if not reg:
+        print("(空,用 link 登记一个 JDK,或 scan --adopt 自动登记)")
+        return
+    print(f"{'名称':<24} {'主版本':<8} {'路径'}")
+    for name, home in reg.items():
+        major = detect_major(home) or "?"
+        print(f"{name:<24} {major:<8} {home}")
+
+
+def cmd_current(_args):
+    home = os.environ.get("JAVA_HOME")
+    if not home:
+        print("(JAVA_HOME 未设置)")
+        return
+    print(f"JAVA_HOME={home}")
+    major = detect_major(home)
+    if major:
+        print(f"主版本: {major}")
+
+
+def cmd_link(args):
+    home = os.path.abspath(args.jdk_home)
+    if not is_valid_jdk_home(home):
+        fail(f"无效的 JDK 路径(找不到 {java_bin_name()}): {home}")
+    reg = load_registry()
+    reg[args.name] = home
+    save_registry(reg)
+    major = detect_major(home) or "?"
+    print(f"已登记 {args.name} -> {home} (主版本 {major})")
+
+
+def cmd_unlink(args):
+    reg = load_registry()
+    if args.name not in reg:
+        fail(f"未找到 {args.name}")
+    del reg[args.name]
+    save_registry(reg)
+    print(f"已移除 {args.name}")
+
+
+def cmd_scan(args):
+    """扫描常见目录列出已装 JDK;--adopt 一键登记未登记的。"""
+    installed = find_installed_jdks()
+    if not installed:
+        print("未在常见目录扫描到 JDK,请用 link 手动登记,或检查 JDK 安装位置。")
+        return
+
+    reg = load_registry()
+    registered_paths = {os.path.abspath(h) for h in reg.values()}
+
+    print(f"{'序号':<6} {'主版本':<8} {'vendor':<12} {'状态':<10} 路径")
+    newly = []
+    for idx, (home, major, vendor) in enumerate(installed, 1):
+        status = "已登记" if home in registered_paths else "未登记"
+        print(f"{idx:<6} {major:<8} {vendor:<12} {status:<10} {home}")
+        if home not in registered_paths:
+            newly.append((home, major, vendor))
+
+    if not args.adopt:
+        if newly:
+            print(f"\n共 {len(newly)} 个未登记,用 `scan --adopt` 一键登记。")
+        else:
+            print("\n扫描到的 JDK 均已登记。")
+        return
+
+    if not newly:
+        print("没有需要登记的新 JDK。")
+        return
+    added = []
+    for home, major, vendor in newly:
+        base = f"{vendor}{major}" if vendor != "jdk" else f"jdk{major}"
+        name = unique_name(base, set(reg.keys()) | {a[0] for a in added})
+        reg[name] = home
+        added.append((name, home, major))
+    save_registry(reg)
+    print(f"\n已登记 {len(added)} 个:")
+    for name, home, major in added:
+        print(f"  {name} -> {home} (主版本 {major})")
+
+
+def cmd_doctor(args):
+    """检查注册表中路径是否仍有效;--prune 清理失效登记。"""
+    reg = load_registry()
+    if not reg:
+        print("注册表为空,无需检查。")
+        return
+    dead = [n for n, h in reg.items() if not is_valid_jdk_home(h)]
+    if not dead:
+        print(f"全部有效({len(reg)} 个)。")
+        return
+    print(f"发现 {len(dead)} 个失效登记:")
+    for n in dead:
+        print(f"  {n} -> {reg[n]}")
+    if args.prune:
+        for n in dead:
+            del reg[n]
+        save_registry(reg)
+        print(f"已清理 {len(dead)} 个失效登记。")
+    else:
+        print("用 `doctor --prune` 清理。")
+
+
+def detect_shell(explicit):
+    if explicit:
+        return explicit
+    if platform.system() == "Windows":
+        return "powershell"
+    return "posix"
+
+
+def cmd_use(args):
+    reg = load_registry()
+    if args.name not in reg:
+        fail(f"未登记的 JDK: {args.name}(先 link 或 scan --adopt)。已登记: {list(reg.keys()) or '无'}")
+    home = reg[args.name]
+    if not is_valid_jdk_home(home):
+        fail(f"登记路径已失效(找不到 {java_bin_name()}): {home}(用 doctor --prune 清理)")
+
+    shell = detect_shell(args.shell)
+    bin_dir = str(Path(home) / "bin")
+
+    if shell == "powershell":
+        print(f'$env:JAVA_HOME = "{home}"')
+        print(f'$env:PATH = "{bin_dir};" + $env:PATH')
+    else:
+        print(f'export JAVA_HOME="{home}"')
+        print(f'export PATH="$JAVA_HOME/bin:$PATH"')
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="跨平台迷你 JDK 版本管理器(替代 jabba,纯标准库)。"
+    )
+    parser.add_argument("-q", "--quiet", action="store_true",
+                        help="失败时静默(只退出码非0,不打印 stderr),供 skill 调用")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_ls = sub.add_parser("ls", help="列出已登记的 JDK")
+    p_ls.set_defaults(func=cmd_ls)
+    p_cur = sub.add_parser("current", help="显示当前 JAVA_HOME 指向的 JDK")
+    p_cur.set_defaults(func=cmd_current)
+
+    p_link = sub.add_parser("link", help="登记一个本机 JDK")
+    p_link.add_argument("name", help="JDK 名称,如 corretto8 / jdk21")
+    p_link.add_argument("jdk_home", help="JDK 根目录(JAVA_HOME)")
+    p_link.set_defaults(func=cmd_link)
+
+    p_unlink = sub.add_parser("unlink", help="移除登记")
+    p_unlink.add_argument("name")
+    p_unlink.set_defaults(func=cmd_unlink)
+
+    p_scan = sub.add_parser("scan", help="扫描常见目录列出已装 JDK")
+    p_scan.add_argument("--adopt", action="store_true",
+                        help="一键登记扫描到的未登记 JDK(显式触发,打印明细)")
+    p_scan.set_defaults(func=cmd_scan)
+
+    p_doc = sub.add_parser("doctor", help="检查注册表中路径是否仍有效")
+    p_doc.add_argument("--prune", action="store_true", help="清理失效登记")
+    p_doc.set_defaults(func=cmd_doctor)
+
+    p_use = sub.add_parser("use", help="输出当前 shell 的 env 设置语句")
+    p_use.add_argument("name")
+    p_use.add_argument("--shell", choices=["posix", "powershell"],
+                       help="指定输出格式,不传按平台判断")
+    p_use.set_defaults(func=cmd_use)
+
+    args = parser.parse_args()
+    global QUIET
+    QUIET = args.quiet
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

package/cbb/tools/cbb-mvn-guide/scripts/mvn_pom_jdk_reader.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+pom_jdk_reader.py — 跨平台读取 Maven pom.xml 的 <java.version> 并归一化主版本号。
+
+逻辑固化,纯标准库,任何装了 Python 3 的机器都能跑。供 cbb-mvn-guide skill 调用,
+避免每次临场写 shell 正则出错。
+
+用法:
+    python pom_jdk_reader.py <pom路径>              # 输出 JSON: {"raw","major","pom_path","interpolated"}
+    python pom_jdk_reader.py <pom路径> --major       # 只输出主版本号(8/21/17...),无匹配输出空行
+    python pom_jdk_reader.py <pom路径> --raw         # 只输出原始值(如 1.8 / 21)
+
+归一化规则:
+    1.8 / 1.8.0_492 / 1.8.0_492-b08  -> 8      (以 1. 开头取第二段)
+    21 / 21.0.10                     -> 21     (否则取首段)
+    其他无法解析                      -> None
+
+父 pom 定位(优先级递减):
+    1. 解析当前 pom 的 <parent><relativePath>(缺省默认 ../pom.xml),按相对路径找父 pom。
+    2. relativePath 指向的文件不存在时,回退到逐级向上目录找同名 pom.xml(兼容旧行为)。
+    3. 都找不到(且 <parent> 只有 groupId/version 无本地路径)→ 停,不联网拉远程父 pom。
+
+属性插值(--resolve-props,默认开):
+    <java.version>${maven.compiler.release}</java.version> 这类值,会尝试从同 pom 的
+    <properties> 解析对应键。解析不到则保留原始 ${...} 字符串并标记 interpolated=false,
+    由 skill 决定是否问用户。失败不报错。
+"""
+
+# 抑制字节码缓存:本脚本作为工具直接调用、无复用价值,避免在 scripts/ 下生成 __pycache__/
+import sys
+if not getattr(sys, 'dont_write_bytecode', False):
+    sys.dont_write_bytecode = True
+
+import argparse
+import json
+import os
+import re
+from xml.etree import ElementTree as ET
+
+# 匹配 <java.version>值</java.version>,容忍空白与注释,取首个非空白内容
+_VERSION_RE = re.compile(r"<java\.version>\s*([^<\s]+)")
+
+# 匹配 <relativePath>值</relativePath>
+_RELATIVE_PATH_RE = re.compile(r"<relativePath>\s*([^<\s]+)")
+
+# ${property.name} 形式
+_PROP_REF_RE = re.compile(r"\$\{([^}]+)\}")
+
+
+def normalize_major(raw):
+    """把原始版本字符串归一化为主版本号字符串,无法解析返回 None。"""
+    if not raw:
+        return None
+    m = re.match(r"^1\.(\d+)", raw)
+    if m:
+        return m.group(1)
+    m = re.match(r"^(\d+)", raw)
+    if m:
+        return m.group(1)
+    return None
+
+
+def extract_properties(content):
+    """从 pom 文本中粗解析 <properties> 下的键值对,返回 dict。
+
+    pom 一般良构,但为容忍 BOM/注释/非闭合等,用正则而非 ET 解析 properties。
+    仅取 properties 块内 <key>value</key> 形式。
+    """
+    props = {}
+    m = re.search(r"<properties>(.*?)</properties>", content, re.DOTALL)
+    if not m:
+        return props
+    block = m.group(1)
+    for pm in re.finditer(r"<([\w.\-]+)>\s*([^<]*?)\s*</\1>", block):
+        props[pm.group(1)] = pm.group(2).strip()
+    return props
+
+
+def interpolate(value, props):
+    """对 ${key} 形式的值做属性插值,递归解析(最多 5 层防循环)。
+
+    返回 (resolved_value, interpolated_flag)。interpolated=True 表示发生过插值且最终值不含 ${}。
+    """
+    if not value or "${" not in value:
+        return value, True
+    seen = 0
+    cur = value
+    while "${" in cur and seen < 5:
+        def repl(m):
+            return props.get(m.group(1), m.group(0))
+        new = _PROP_REF_RE.sub(repl, cur)
+        if new == cur:
+            break  # 无可解析的引用,停
+        cur = new
+        seen += 1
+    interpolated = "${" not in cur
+    return cur, interpolated
+
+
+def find_parent_pom(content, current_pom):
+    """根据 <parent><relativePath> 定位父 pom 路径;回退到逐级向上找同名 pom.xml。
+
+    返回父 pom 绝对路径,找不到返回 None。
+    """
+    cur_dir = os.path.dirname(os.path.abspath(current_pom))
+
+    # 1. 解析 relativePath(缺省默认 ../pom.xml)
+    rp_match = _RELATIVE_PATH_RE.search(content)
+    relative = rp_match.group(1).strip() if rp_match else "../pom.xml"
+    parent_candidate = os.path.normpath(os.path.join(cur_dir, relative))
+    if os.path.isfile(parent_candidate):
+        return parent_candidate
+
+    # 2. 回退:逐级向上找同名 pom.xml(兼容旧行为与无 <parent> 标签的多模块)
+    current = os.path.abspath(current_pom)
+    while True:
+        parent_dir = os.path.dirname(os.path.dirname(current))
+        parent_pom = os.path.join(parent_dir, "pom.xml")
+        if parent_pom == current or not os.path.isfile(parent_pom):
+            return None
+        return parent_pom  # 只回退一级,避免无限上溯;如需继续由递归调用处理
+
+
+def read_pom_version(pom_path, resolve_props=True):
+    """
+    从 pom_path 起读 <java.version>;本 pom 没有则按 relativePath/上级目录找父 pom。
+    返回 (raw, major, found_pom_path, interpolated);都没找到返回 (None, None, pom_path, True)。
+    """
+    current = os.path.abspath(pom_path)
+    if not os.path.isfile(current):
+        return None, None, current, True
+
+    visited = set()
+    while current and current not in visited:
+        visited.add(current)
+        try:
+            with open(current, "r", encoding="utf-8", errors="replace") as f:
+                content = f.read()
+        except OSError:
+            break
+
+        m = _VERSION_RE.search(content)
+        if m:
+            raw = m.group(1).strip()
+            if resolve_props and "${" in raw:
+                props = extract_properties(content)
+                raw, interpolated = interpolate(raw, props)
+            else:
+                interpolated = "${" not in raw
+            return raw, normalize_major(raw), current, interpolated
+
+        # 本 pom 无 <java.version>,找父 pom
+        parent = find_parent_pom(content, current)
+        if not parent or parent == current:
+            break
+        current = parent
+
+    return None, None, os.path.abspath(pom_path), True
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="读取 Maven pom.xml 的 <java.version> 并归一化主版本号(跨平台)。"
+    )
+    parser.add_argument("pom", help="pom.xml 路径")
+    parser.add_argument(
+        "--major", action="store_true", help="只输出主版本号(如 8/21)"
+    )
+    parser.add_argument(
+        "--raw", action="store_true", help="只输出原始值(如 1.8 / 21)"
+    )
+    parser.add_argument(
+        "--no-resolve-props", action="store_true",
+        help="关闭 ${} 属性插值,保留原始引用字符串"
+    )
+    args = parser.parse_args()
+
+    raw, major, found_path, interpolated = read_pom_version(
+        args.pom, resolve_props=not args.no_resolve_props
+    )
+
+    if args.major:
+        print(major if major is not None else "")
+        return
+    if args.raw:
+        print(raw if raw is not None else "")
+
+    print(json.dumps({
+        "raw": raw,
+        "major": major,
+        "pom_path": found_path,
+        "interpolated": interpolated,
+    }, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    sys.exit(main())