Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
7.6 KB
Raw Blame
 #!/usr/bin/env python3
from __future__ import annotations

import argparse
import logging
import os
import shutil
import subprocess
import sys
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]
SIDECAR_ROOT = ROOT / "packages" / "jiuwenswarm-tui"
SIDE_CAR_DIST = SIDECAR_ROOT / "dist"
# 运行时依赖是 pyproject 里的 git 包。这里只在显式打 jiuwenbox wheel 时
# 使用本机源码树:同级 agent-security 优先,否则用本仓库残留的 jiuwenbox/。
_EXTERNAL_JIUWENBOX = ROOT.parent / "agent-security" / "jiuwenbox"
JIUWENBOX_ROOT = (
    _EXTERNAL_JIUWENBOX
    if (_EXTERNAL_JIUWENBOX / "pyproject.toml").is_file()
    else ROOT / "jiuwenbox"
)
JIUWENBOX_DIST = JIUWENBOX_ROOT / "dist"
TUI_ROOT = ROOT / "jiuwenswarm" / "channels" / "tui" / "frontend"

TUI_TARGETS = {
    "linux-x64": "linux_x86_64",
    "linux-arm64": "linux_aarch64",
    #"macos-x64": "macosx_10_15_x86_64",
    "macos-arm64": "macosx_11_0_arm64",
    "windows-x64": "win_amd64",
    #"windows-arm64": "win_arm64",
}


def run(cmd: list[str], cwd: Path, env: dict[str, str] | None = None) -> None:
    try:
        shown = "." if cwd == ROOT else cwd.relative_to(ROOT)
    except ValueError:
        shown = cwd
    logging.info(f"[build] ({shown}) {' '.join(cmd)}")
    subprocess.run(cmd, cwd=cwd, check=True, env=env)


def remove_path(path: Path) -> None:
    if path.is_dir():
        shutil.rmtree(path)
        return
    if path.exists():
        path.unlink()


def clean_root() -> None:
    for relative in ("build", "jiuwenswarm.egg-info"):
        remove_path(ROOT / relative)


def clean_sidecar() -> None:
    for relative in ("dist", "build", "jiuwenswarm_tui.egg-info"):
        remove_path(SIDECAR_ROOT / relative)


def clean_jiuwenbox() -> None:
    for relative in ("dist", "build", "jiuwenbox.egg-info"):
        remove_path(JIUWENBOX_ROOT / relative)


def build_root_wheel() -> None:
    SIDE_CAR_DIST.mkdir(parents=True, exist_ok=True)
    run(["uv", "build", "--wheel", "--out-dir", str(SIDE_CAR_DIST)], ROOT)


def build_sidecar_wheel(platform_tag: str | None = None) -> None:
    for relative in ("build", "jiuwenswarm_tui.egg-info"):
        remove_path(SIDECAR_ROOT / relative)
    env = os.environ.copy()
    if platform_tag:
        env["JWC_TUI_WHEEL_PLATFORM"] = platform_tag
    run(["uv", "build", "--wheel"], SIDECAR_ROOT, env=env)


def build_jiuwenbox_wheel() -> None:
    for relative in ("build", "jiuwenbox.egg-info"):
        remove_path(JIUWENBOX_ROOT / relative)
    JIUWENBOX_DIST.mkdir(parents=True, exist_ok=True)
    run(["uv", "build", "--wheel", "--out-dir", str(JIUWENBOX_DIST)], JIUWENBOX_ROOT)


def build_tui_binary(target: str, clean: bool) -> None:
    cmd = [sys.executable, "scripts/build_tui.py", "--target", target]
    if clean:
        cmd.append("--clean")
    run(cmd, ROOT)


class MissingJsDependenciesError(RuntimeError):
    """Raised when TUI frontend node_modules is missing and auto-install is disabled."""


class InvalidTargetError(ValueError):
    """Raised when --target contains unknown TUI build target(s)."""


def ensure_js_dependencies(install: bool) -> None:
    node_modules = TUI_ROOT / "node_modules"
    if node_modules.exists():
        return

    if not install:
        raise MissingJsDependenciesError(
            "\n".join(
                [
                    "missing JavaScript dependencies for jiuwenswarm/channels/tui/frontend",
                    f"expected: {node_modules}",
                    "run one of:",
                    "  cd jiuwenswarm/channels/tui/frontend && npm install",
                    "  python scripts/build_python_packages.py --install-js-deps",
                ]
            )
        )

    if (TUI_ROOT / "package-lock.json").exists():
        run(["npm", "install"], TUI_ROOT)
        return

    if (TUI_ROOT / "bun.lock").exists() or (TUI_ROOT / "bun.lockb").exists():
        run(["bun", "install"], TUI_ROOT)
        return

    run(["npm", "install"], TUI_ROOT)


def resolve_requested_targets(raw: str) -> list[str]:
    if raw == "all":
        return list(TUI_TARGETS.keys())
    values = [part.strip() for part in raw.split(",") if part.strip()]
    if raw == "current":
        return ["current"]
    unknown = [value for value in values if value not in TUI_TARGETS]
    if unknown:
        valid = ", ".join(["current", "all", *TUI_TARGETS.keys()])
        raise InvalidTargetError(f"unknown target(s): {', '.join(unknown)}; valid: {valid}")
    return values


def main() -> None:
    parser = argparse.ArgumentParser(
        description=(
            "Build JiuwenSwarm Python distributions "
            "(main package, optional TUI sidecar, and optional jiuwenbox wheel)."
        ),
    )
    parser.add_argument(
        "--target",
        default="current",
        help="TUI binary target passed to build_tui.py (default: current)",
    )
    parser.add_argument(
        "--out-dir",
        default="./packages/jiuwenswarm-tui/dist",
        help="Directory to output the built TUI binary (default: ./packages/jiuwenswarm-tui/dist)",
    )
    parser.add_argument(
        "--skip-binary",
        action="store_true",
        help="Skip building the native TUI binary before building the sidecar wheel",
    )
    parser.add_argument(
        "--skip-root",
        action="store_true",
        help="Skip building the main jiuwenswarm wheel",
    )
    parser.add_argument(
        "--skip-sidecar",
        action="store_true",
        help="Skip building the jiuwenswarm-tui sidecar wheel",
    )
    parser.add_argument(
        "--skip-jiuwenbox",
        action="store_true",
        help="Skip building the jiuwenbox wheel",
    )
    parser.add_argument(
        "--clean",
        action="store_true",
        help="Clean dist/build/egg-info before building",
    )
    parser.add_argument(
        "--install-js-deps",
        action="store_true",
        help="Install jiuwenswarm/channels/tui/frontend JavaScript dependencies if node_modules is missing",
    )
    args = parser.parse_args()
    targets = resolve_requested_targets(args.target)

    if args.clean:
        if not args.skip_root:
            clean_root()
        if not args.skip_sidecar:
            clean_sidecar()
        if not args.skip_jiuwenbox:
            clean_jiuwenbox()

    if args.skip_sidecar and args.skip_root and args.skip_jiuwenbox:
        raise SystemExit("nothing to build: --skip-root, --skip-sidecar, and --skip-jiuwenbox were all set")

    if args.skip_binary and not args.skip_sidecar and len(targets) > 1:
        raise SystemExit("--skip-binary only supports a single sidecar wheel target")

    if not args.skip_sidecar and not args.skip_binary:
        ensure_js_dependencies(args.install_js_deps)

    if not args.skip_root:
        build_root_wheel()

    if not args.skip_sidecar:
        for index, target in enumerate(targets):
            if not args.skip_binary:
                build_tui_binary(target, clean=args.clean or index > 0)
            platform_tag = None if target == "current" else TUI_TARGETS[target]
            build_sidecar_wheel(platform_tag=platform_tag)

    if not args.skip_jiuwenbox:
        build_jiuwenbox_wheel()

    logging.info("\n[build] done")
    if not args.skip_root:
        logging.info(f"[build] main wheel: {SIDE_CAR_DIST}")
    if not args.skip_sidecar:
        logging.info(f"[build] tui wheel(s): {SIDE_CAR_DIST}")
    if not args.skip_jiuwenbox:
        logging.info(f"[build] jiuwenbox wheel: {JIUWENBOX_DIST}")


if __name__ == "__main__":
    try:
        main()
    except (MissingJsDependenciesError, InvalidTargetError) as exc:
        raise SystemExit(str(exc)) from exc
    except subprocess.CalledProcessError as exc:
        raise SystemExit(exc.returncode) from exc