xt-cli 0.2.1__py3-none-any.whl

commands/deps_cmd.py

@@ -0,0 +1,128 @@
+"""deps 命令：管理工程版本依赖。"""
+from __future__ import annotations
+
+import argparse
+
+from cli import register_task
+from constants import PRIORITY_INDEPENDENT
+from models import BuildContext
+from dependencies import (
+    _get_entry_version, _load_jsonc, _print_error, _print_info,
+    _resolve_repo_path, _save_jsonc, hash_dir,
+)
+
+
+def add_args_deps(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--update-deps-require", nargs="?", const="__ALL__", default=None,
+                        metavar="<name>",
+                        help="Update require to current HEAD sha")
+    parser.add_argument("--hash", metavar="<path>",
+                        help="Compute SHA-256 hash of a directory")
+    parser.epilog = (
+        "Examples:\n"
+        "  xt deps --update-deps-require                  Update all entries\n"
+        "  xt deps --update-deps-require=lm620             Update single platform\n"
+        "  xt deps --update-deps-require=xt-sdk,lm620      Update multiple (comma-separated)\n"
+        "  xt deps --hash components/my_utils               Compute directory hash"
+    )
+
+
+def handle_deps_command(
+    context: BuildContext,
+    global_args: argparse.Namespace,
+    shared_args: argparse.Namespace,
+    self_args: argparse.Namespace,
+    unknown_args: list[str],
+) -> int:
+    if self_args.update_deps_require is not None:
+        if context is None:
+            from context import build_context_from_options
+            context = build_context_from_options(
+                cwd=global_args.project,
+                project_dir=global_args.project,
+                sdk_dir=global_args.sdk,
+                target=global_args.target,
+                toolchain_path=global_args.toolchain_path,
+                board=global_args.board,
+            )
+        return _handle_update_require(context, self_args.update_deps_require)
+    if self_args.hash is not None:
+        print(hash_dir(self_args.hash))
+        return 0
+    print("Usage: xt deps --update-deps-require[=<name>[,<name>...]]")
+    print("       xt deps --hash <path>")
+    return 0
+
+
+def _handle_update_require(context, raw_value: str) -> int:
+    deps_path = context.project_dir / "xt_deps.jsonc"
+    xt_deps = _load_jsonc(deps_path)
+    if xt_deps is None:
+        _print_error("xt_deps.jsonc not found")
+        return 1
+
+    if raw_value == "__ALL__":
+        names = _collect_entry_names(xt_deps)
+    else:
+        names = [s.strip() for s in raw_value.split(",") if s.strip()]
+
+    for name in names:
+        entry, repo_path = _resolve_entry_and_path(name, xt_deps, context)
+        if entry is None:
+            _print_error(f"{name}: not found in xt_deps.jsonc")
+            return 1
+        if not (repo_path / ".git").exists():
+            h = hash_dir(repo_path)
+            entry["require"] = {"type": "hash", "val": h}
+            _print_info(f"{name}: require → hash {h}")
+        else:
+            version = _get_entry_version(repo_path)
+            entry["require"] = version.split("-")[0]
+            _print_info(f"{name}: require → {entry['require']}")
+
+    _save_jsonc(deps_path, xt_deps)
+    return 0
+
+
+def _collect_entry_names(xt_deps: dict) -> list[str]:
+    names: list[str] = []
+    if "xt-sdk" in xt_deps:
+        names.append("xt-sdk")
+    platforms = xt_deps.get("platforms", {})
+    if isinstance(platforms, dict):
+        names.extend(platforms.keys())
+    components = xt_deps.get("components", {})
+    if isinstance(components, dict):
+        names.extend(components.keys())
+    return names
+
+
+def _resolve_entry_and_path(name: str, xt_deps: dict, context):
+    """解析条目和仓库路径。"""
+    if name == "xt-sdk":
+        entry = xt_deps.get("xt-sdk")
+        if isinstance(entry, dict):
+            return entry, context.sdk_dir
+        return None, None
+
+    platforms = xt_deps.get("platforms", {})
+    if isinstance(platforms, dict):
+        entry = platforms.get(name)
+        if isinstance(entry, dict):
+            repo_path = _resolve_repo_path(name, entry, context)
+            return entry, repo_path
+
+    components = xt_deps.get("components", {})
+    if isinstance(components, dict):
+        entry = components.get(name)
+        if isinstance(entry, dict):
+            from dependencies import _resolve_component_path
+            repo_path = _resolve_component_path(name, entry, context)
+            return entry, repo_path
+
+    return None, None
+
+
+register_task("deps", handle_deps_command, independent=True,
+              add_parser=add_args_deps, help="Manage project dependencies",
+              priority=PRIORITY_INDEPENDENT)

commands/fullclean_cmd.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import argparse
+import shutil
+
+from cli import register_task
+from hooks import dispatch_hook
+from models import BuildContext
+from output import print_step
+
+
+def handle_fullclean_command(context: BuildContext, global_args: argparse.Namespace, shared_args: argparse.Namespace, self_args: argparse.Namespace, unknown_args: list[str]) -> int:
+    """处理 fullclean 命令——直接删除 .xmake 和 .build 目录。"""
+    hook_result = dispatch_hook(context, "fullclean", unknown_args, global_args=global_args, shared_args=shared_args, self_args=self_args)
+    if hook_result.handled:
+        return hook_result.returncode
+
+    from hooks import run_lifecycle_hook
+
+    before_ret = run_lifecycle_hook(context, "before_fullclean", unknown_args, global_args, shared_args, self_args)
+    if before_ret != 0:
+        return before_ret
+
+    print_step("fullclean")
+    shutil.rmtree(context.project_dir / ".xmake", ignore_errors=True)
+    shutil.rmtree(context.project_dir / ".build", ignore_errors=True)
+
+    run_lifecycle_hook(context, "after_fullclean", unknown_args, global_args, shared_args, self_args)
+    return 0
+
+
+register_task("fullclean", handle_fullclean_command, independent=False, help="Delete build output directories", priority=10)

config.py

@@ -0,0 +1,356 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import json5
+
+from constants import CONFIG_VERSION, DEFAULT_TARGET
+from errors import ConfigError
+from paths import build_global_config_path, normalize_path
+
+_LOCAL_CONFIG_FILENAME = "xt_conf.jsonc"
+_TOOLCHAINS_KEY = "toolchains"
+_TOOLCHAIN_PATH_KEY = "toolchain-path"
+_CONFIG_VERSION_KEY = "config_version"
+_SDK_MARKER_RELATIVE_PATH = Path(".xt-sdk-version")
+
+
+def _normalize_config_key(key: str) -> str:
+    """规范化配置键。deps-on-* → deps.on_*，兼容 CLI 标志格式。"""
+    if key.startswith("deps-"):
+        rest = key[5:]
+        return "deps." + rest.replace("-", "_")
+    return key
+
+
+class ConfigStore:
+    """负责配置文件的读写。"""
+
+    def __init__(self, path: str | Path) -> None:
+        self._path = normalize_path(path)
+
+    @property
+    def path(self) -> Path:
+        """返回配置文件路径。"""
+        return self._path
+
+    def load(self) -> dict[str, Any]:
+        """加载配置文件内容。"""
+        raw_text = self._path.read_text(encoding="utf-8")
+        data = json5.loads(raw_text)
+        if not isinstance(data, dict):
+            raise ConfigError("Config data must be a JSON object")
+        normalized_data = _ensure_config_version(data)
+        if normalized_data != data:
+            self.save(normalized_data)
+        return normalized_data
+
+    def save(self, data: dict[str, Any]) -> None:
+        """保存配置文件内容。"""
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        normalized_data = _ensure_config_version(data)
+        self._path.write_text(
+            json.dumps(normalized_data, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+
+    def load_or_default(self) -> dict[str, Any]:
+        """加载配置文件，不存在时返回空对象。"""
+        if not self._path.exists():
+            return {}
+        return self.load()
+
+    def upsert_key(self, key: str, value: Any) -> None:
+        """设置顶层配置项。"""
+        data = self.load_or_default()
+        data[key] = value
+        self.save(data)
+
+    def upsert_nested_key(self, parent_key: str, child_key: str, value: Any) -> None:
+        """设置嵌套配置项。"""
+        data = self.load_or_default()
+        child_data = data.get(parent_key)
+        if not isinstance(child_data, dict):
+            child_data = {}
+        child_data[child_key] = value
+        data[parent_key] = child_data
+        self.save(data)
+
+    def reset_key(self, key: str) -> bool:
+        """重置指定配置项。"""
+        if not self._path.exists():
+            return False
+
+        data = self.load()
+        if key not in data:
+            return False
+
+        del data[key]
+        if _has_user_config(data):
+            self.save(data)
+        else:
+            self._path.unlink()
+        return True
+
+    def reset_nested_key(self, parent_key: str, child_key: str) -> bool:
+        """重置嵌套配置项。"""
+        if not self._path.exists():
+            return False
+
+        data = self.load()
+        child_data = data.get(parent_key)
+        if not isinstance(child_data, dict) or child_key not in child_data:
+            return False
+
+        del child_data[child_key]
+        if child_data:
+            data[parent_key] = child_data
+        else:
+            del data[parent_key]
+
+        if _has_user_config(data):
+            self.save(data)
+        else:
+            self._path.unlink()
+        return True
+
+
+def set_config_value(
+    key: str,
+    value: str,
+    platform: str | None,
+    use_local: bool,
+    cwd: str | Path,
+    home: str | Path | None = None,
+) -> str:
+    """设置指定配置项并返回来源。"""
+    config_store = _resolve_config_store(use_local=use_local, cwd=cwd, home=home)
+    normalized_value = _normalize_config_value_for_store(
+        key=key,
+        value=value,
+        cwd=Path(cwd),
+    )
+    if key == _TOOLCHAIN_PATH_KEY:
+        normalized_platform = _require_platform(platform, key)
+        config_store.upsert_nested_key(_TOOLCHAINS_KEY, normalized_platform, normalized_value)
+        return _describe_source(use_local)
+
+    if key.startswith("deps."):
+        sub_key = key[5:]
+        config_store.upsert_nested_key("deps_configs", sub_key, normalized_value)
+        return _describe_source(use_local)
+
+    config_store.upsert_key(key, normalized_value)
+    return _describe_source(use_local)
+
+
+def get_config_value(
+    key: str,
+    platform: str | None,
+    use_local: bool,
+    cwd: str | Path,
+    home: str | Path | None = None,
+) -> tuple[str | int, str]:
+    """获取指定配置项的值与来源。"""
+    key = _normalize_config_key(key)
+    if key == "config-version":
+        return CONFIG_VERSION, "cli"
+
+    if use_local:
+        local_store = _resolve_config_store(use_local=True, cwd=cwd, home=home)
+        local_data = local_store.load_or_default()
+        local_value = _extract_config_value(local_data, key, platform)
+        if local_value is not None:
+            return local_value, _describe_source(True)
+        if key == "target":
+            return DEFAULT_TARGET, "default"
+        if key == "debug":
+            return 0, "default"
+        raise ConfigError(f"Unknown config key: {key}")
+
+    local_store = _resolve_config_store(use_local=True, cwd=cwd, home=home)
+    local_data = local_store.load_or_default()
+    local_value = _extract_config_value(local_data, key, platform)
+    if local_value is not None:
+        return local_value, _describe_source(True)
+
+    global_store = _resolve_config_store(use_local=False, cwd=cwd, home=home)
+    global_data = global_store.load_or_default()
+    global_value = _extract_config_value(global_data, key, platform)
+    if global_value is not None:
+        return global_value, _describe_source(False)
+
+    if key == "target":
+        return DEFAULT_TARGET, "default"
+    if key == "board":
+        return "", "default"
+    if key == "debug":
+        return 0, "default"
+    if key == "deps.on_version_fail":
+        return "warn", "default"
+    if key == "deps.on_target_fail":
+        return "warn", "default"
+    if key == "deps.track":
+        return False, "default"
+
+    raise KeyError(key)
+
+
+def reset_config_key(
+    key: str,
+    platform: str | None,
+    use_local: bool,
+    cwd: str | Path,
+    home: str | Path | None = None,
+) -> str:
+    """重置指定配置项并返回来源。"""
+    key = _normalize_config_key(key)
+    config_store = _resolve_config_store(use_local=use_local, cwd=cwd, home=home)
+    if key == _TOOLCHAIN_PATH_KEY:
+        normalized_platform = _require_platform(platform, key)
+        config_store.reset_nested_key(_TOOLCHAINS_KEY, normalized_platform)
+        return _describe_source(use_local)
+
+    if key.startswith("deps."):
+        sub_key = key[5:]
+        config_store.reset_nested_key("deps_configs", sub_key)
+        return _describe_source(use_local)
+
+    config_store.reset_key(key)
+    return _describe_source(use_local)
+
+
+def _describe_source(use_local: bool) -> str:
+    """返回配置来源描述。"""
+    return "local config" if use_local else "global config"
+
+
+def _maybe_migrate_config(new_path: Path) -> None:
+    """如果旧配置文件 .xt_conf.jsonc 存在且新文件不存在，自动重命名。"""
+    old_path = new_path.parent / ".xt_conf.jsonc"
+    if not new_path.exists() and old_path.exists():
+        old_path.rename(new_path)
+        print(f"[xt cli] Migrated config: .xt_conf.jsonc → xt_conf.jsonc")
+
+
+def _resolve_config_store(
+    *,
+    use_local: bool,
+    cwd: str | Path,
+    home: str | Path | None,
+) -> ConfigStore:
+    """按作用域返回配置存储。"""
+    if use_local:
+        new_path = Path(cwd) / _LOCAL_CONFIG_FILENAME
+    else:
+        new_path = build_global_config_path(home)
+    _maybe_migrate_config(new_path)
+    return ConfigStore(new_path)
+
+
+def _extract_config_value(data: dict[str, Any], key: str, platform: str | None) -> str | int | None:
+    """从配置对象中提取指定值。"""
+    if key == _TOOLCHAIN_PATH_KEY:
+        normalized_platform = _require_platform(platform, key)
+        toolchains = data.get(_TOOLCHAINS_KEY)
+        if not isinstance(toolchains, dict):
+            return None
+        value = toolchains.get(normalized_platform)
+        return value if isinstance(value, (str, int)) else None
+
+    if key.startswith("deps."):
+        sub_key = key[5:]
+        deps = data.get("deps_configs")
+        if isinstance(deps, dict):
+            value = deps.get(sub_key)
+            if sub_key == "track":
+                if isinstance(value, bool):
+                    return value
+                if isinstance(value, str):
+                    return value.lower() in ("true", "1")
+                return None
+            return value if isinstance(value, str) else None
+        return None
+
+    value = data.get(key)
+    if key == "sdk" and isinstance(value, str):
+        return str(Path(value))
+    if key == "debug" and isinstance(value, int):
+        return value
+    return value if isinstance(value, (str, int)) else None
+
+
+def _normalize_config_value_for_store(key: str, value: str, cwd: Path) -> str | int | bool:
+    """规范化需要落盘的配置值。"""
+    if key == "deps.track":
+        if isinstance(value, bool):
+            return value
+        if value.lower() in ("true", "1"):
+            return True
+        if value.lower() in ("false", "0"):
+            return False
+        raise ConfigError("deps.track must be true or false")
+
+    if key.startswith("deps."):
+        if value not in ("warn", "error", "ignore"):
+            raise ConfigError("deps on_fail value must be warn, error, or ignore")
+        return value
+
+    if key == "debug":
+        return _parse_debug_value(value)
+    if key != "sdk":
+        return value
+
+    normalized_value = Path(value).expanduser()
+    if not normalized_value.is_absolute():
+        normalized_value = (cwd / normalized_value).resolve()
+    _validate_sdk_dir(normalized_value)
+    return normalized_value.as_posix()
+
+
+def _require_platform(platform: str | None, key: str) -> str:
+    """校验需要平台参数的配置项。"""
+    if key == _TOOLCHAIN_PATH_KEY and not platform:
+        raise ConfigError("Platform is required for toolchain-path")
+    return "" if platform is None else platform
+
+
+def _describe_source(use_local: bool) -> str:
+    """返回配置来源描述。"""
+    return "local config" if use_local else "global config"
+
+
+def _ensure_config_version(data: dict[str, Any]) -> dict[str, Any]:
+    """确保配置版本号始终位于首行。"""
+    normalized_data = dict(data)
+    config_version = normalized_data.pop(_CONFIG_VERSION_KEY, None)
+    if config_version is None:
+        config_version = CONFIG_VERSION
+    return {
+        _CONFIG_VERSION_KEY: config_version,
+        **normalized_data,
+    }
+
+
+def _has_user_config(data: dict[str, Any]) -> bool:
+    """判断是否还存在用户配置项。"""
+    return any(key != _CONFIG_VERSION_KEY for key in data)
+
+
+def _parse_debug_value(value: str) -> int:
+    """解析调试开关配置值。"""
+    if value not in {"0", "1"}:
+        raise ConfigError("Debug value must be 0 or 1")
+    return int(value)
+
+
+def _validate_sdk_dir(sdk_dir: Path) -> None:
+    """校验 sdk 目录结构。"""
+    sdk_marker = sdk_dir / _SDK_MARKER_RELATIVE_PATH
+    if sdk_marker.is_file():
+        return
+    raise ConfigError(
+        f"Invalid sdk directory: {sdk_dir}. Missing required file: .xt-sdk-version"
+    )

constants.py

@@ -0,0 +1,6 @@
+"""xt-cli 核心常量。"""
+
+CONFIG_VERSION = 1
+DEFAULT_TARGET = "windows/simulator"
+PRIORITY_DEFAULT = 100      # hook task 默认优先级
+PRIORITY_INDEPENDENT = 100  # independent task 优先级