mcpywrap 0.3.6__tar.gz → 0.3.7__tar.gz

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 更新记录
 
+## 0.3.7
+
+- 明确工具 Python 与游戏内置 Python 的边界：普通包保留为开发依赖，CLI、JSON 与 GUI 提示“仅开发环境”，不会自动进入游戏产物。
+- 主项目、递归 Addon 依赖与地图包中的原生二进制会在构建、打包、运行或编辑前被拒绝；增量更新同样校验，失败保留已有产物。
+- 包安装后校验候选声明，无效 Addon 不写配置；明确提示已发生的工具环境安装，不自动卸载。
+- README 与 Skill 补充依赖分类、游戏兼容性及实际产物验收要求；开发项目和独立解包产物均已通过本机客户端／服务端共享源码加载测试。
+
 ## 0.3.6
 
 - 新增局域网 serve 服务与 --remote/--local 路由；macOS 本机开发、Windows 网络游戏测试共用 CLI 和 Skill。

{mcpywrap-0.3.6/mcpywrap.egg-info → mcpywrap-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpywrap
-Version: 0.3.6
+Version: 0.3.7
 Summary: A wrapper for Minecraft China Edition Addons management
 Author-email: boybook <boybook@easecation.net>
 License-Expression: MIT
@@ -32,7 +32,7 @@ Dynamic: license-file
 [![PyPI Version](https://img.shields.io/pypi/v/mcpywrap)](https://pypi.org/project/mcpywrap/)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-mcpywrap 使用 `pyproject.toml` 管理项目，支持安装 Python 包依赖，也支持直接引用本地 Addon 目录。它将依赖管理、资源构建、游戏运行和 MC Studio 编辑器串成一套开发流程，方便多个项目共享代码与资源。
+mcpywrap 使用 `pyproject.toml` 管理开发侧依赖，复用本地 Addon 的代码与资源，并串联构建、游戏测试和 MC Studio 编辑器。Python 包管理用于开发环境，不是游戏内的包安装器。
 
 ## 安装
 
@@ -65,7 +65,7 @@ mcpy edit
 
 ## 复用代码和资源
 
-对于已发布的 Python 包，使用包名添加依赖：
+将 Python 包安装到 mcpy 所在的工具环境并记录声明：
 
 ```powershell
 mcpy add "package-name>=1.0"
@@ -81,7 +81,9 @@ mcpy add --path "../shared-addon"
 
 移除依赖使用 `mcpy remove <包名>` 或 `mcpy remove --path <目录>`。移除本地引用不会删除源目录。不带参数运行 `mcpy add` / `mcpy remove` 可进入选择向导。
 
-本地路径适合同机开发；与他人共享项目时，需要同步这些目录，或将可复用组件发布为 Python 包。目录结构、配置及构建规则见[本地依赖参考](https://github.com/EaseCation/mcpywrap/blob/main/docs/local-dependencies.md)。
+本地路径适合同机开发；共享项目时需同步这些目录。工具目前通过包的本地安装来源识别 Addon，普通 PyPI 包或 wheel 安装成功不代表能参与组装；未识别到 Addon 的包会标记为“仅开发环境”。目录结构、配置及构建规则见[本地依赖参考](https://github.com/EaseCation/mcpywrap/blob/main/docs/local-dependencies.md)。
+
+**游戏运行边界：** 测试和正式游戏都使用内置 Python，不读取 `dependencies`，也不继承工具环境的 `site-packages`。`add`、`sync --install` 和 ModSDK 安装均不向游戏安装模块。游戏所需代码与资源必须随 Addon 携带，或由用户加载相应 Mod；纯 Python 库也不会自动复制，仍需适配游戏解释器和 ModSDK。原生扩展及依赖外部安装步骤、系统环境的库不能直接用于游戏；包内 `.pyd/.dll/.so/.so.*（版本号）/.dylib` 会阻止构建和启动。
 
 ## 构建与日常开发
 
@@ -100,12 +102,14 @@ mcpy add --path "../shared-addon"
 
 ### 打包分发
 
-在项目根目录执行 `mcpy package`，会先构建项目及 Python 包／本地 Addon 依赖，再生成 `dist/<项目名>-<版本>.zip`。名称和版本读取 `pyproject.toml` 的 `[project]`；不需要配置 `target_dir`。
+在项目根目录执行 `mcpy package`，会组装项目及已识别的 Addon 依赖，再生成 `dist/<项目名>-<版本>.zip`；仅开发环境的包不会进入 ZIP。名称和版本读取 `pyproject.toml` 的 `[project]`；不需要配置 `target_dir`。
 
 Addon ZIP 内为 `<项目名>_bp/`、`<项目名>_rp/`（仅包含实际构建出的包）；地图 ZIP 根目录直接包含存档数据、行为包、资源包及世界包配置。地图默认保留独立包，使用 `mcpy package --merge`（或 `-m`）按构建规则合并依赖资源。构建产物中的空目录会保留。
 
 重复打包成功后会替换同名 ZIP；失败时保留已有 ZIP，临时文件自动清理。
 
+`publish` 向 PyPI 发布 Python 分发包，与游戏 ZIP 分发不同。本地测试可配置多个独立 Addon，游戏不会解析 Python 依赖图；构建成功不保证兼容，发布前应检查产物并在游戏中验证加载日志。
+
 ## 游戏启动与排查
 
 通常不需要手动指定游戏路径。mcpywrap 会优先查找 MC Studio 登记的安装，必要时搜索固定磁盘中的标准下载目录，并跳过不完整的引擎版本。
@@ -173,7 +177,7 @@ mcpy --project D:\tests\server stop --session <id> --json
 也可以下载仓库 ZIP，将完整的 `skills/mcpywrap` 文件夹复制到对应 Agent 的技能目录。
 无需从源码安装 Python 项目；CLI 和 Skill 分别安装，`pip/uv install` 不会自动注册 Skill。
 两端使用跨平台 `scripts/bootstrap.py` 安装或复用各自的 CLI，Windows 也可用 `bootstrap.ps1`。脚本分别报告本机与远端能力；Skill、CLI 与 Windows 服务需要分别检查，Git／可编辑安装可能缺少登录组件。
-局域网流程请使用 mcpywrap 0.3.6 或更高版本，可从 `v0.3.6` 标签安装配套 Skill。实际能力仍以脚本检测为准；更新 Skill 不会自动更新两端 CLI。
+推荐使用 mcpywrap 0.3.7 或更高版本，并从 `v0.3.7` 标签安装配套 Skill，以获得依赖边界提示与校验。实际能力仍以脚本检测为准；更新 Skill 不会自动更新两端 CLI。
 
 安装后可直接描述任务：
 

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/README.md

@@ -5,7 +5,7 @@
 [![PyPI Version](https://img.shields.io/pypi/v/mcpywrap)](https://pypi.org/project/mcpywrap/)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-mcpywrap 使用 `pyproject.toml` 管理项目，支持安装 Python 包依赖，也支持直接引用本地 Addon 目录。它将依赖管理、资源构建、游戏运行和 MC Studio 编辑器串成一套开发流程，方便多个项目共享代码与资源。
+mcpywrap 使用 `pyproject.toml` 管理开发侧依赖，复用本地 Addon 的代码与资源，并串联构建、游戏测试和 MC Studio 编辑器。Python 包管理用于开发环境，不是游戏内的包安装器。
 
 ## 安装
 
@@ -38,7 +38,7 @@ mcpy edit
 
 ## 复用代码和资源
 
-对于已发布的 Python 包，使用包名添加依赖：
+将 Python 包安装到 mcpy 所在的工具环境并记录声明：
 
 ```powershell
 mcpy add "package-name>=1.0"
@@ -54,7 +54,9 @@ mcpy add --path "../shared-addon"
 
 移除依赖使用 `mcpy remove <包名>` 或 `mcpy remove --path <目录>`。移除本地引用不会删除源目录。不带参数运行 `mcpy add` / `mcpy remove` 可进入选择向导。
 
-本地路径适合同机开发；与他人共享项目时，需要同步这些目录，或将可复用组件发布为 Python 包。目录结构、配置及构建规则见[本地依赖参考](https://github.com/EaseCation/mcpywrap/blob/main/docs/local-dependencies.md)。
+本地路径适合同机开发；共享项目时需同步这些目录。工具目前通过包的本地安装来源识别 Addon，普通 PyPI 包或 wheel 安装成功不代表能参与组装；未识别到 Addon 的包会标记为“仅开发环境”。目录结构、配置及构建规则见[本地依赖参考](https://github.com/EaseCation/mcpywrap/blob/main/docs/local-dependencies.md)。
+
+**游戏运行边界：** 测试和正式游戏都使用内置 Python，不读取 `dependencies`，也不继承工具环境的 `site-packages`。`add`、`sync --install` 和 ModSDK 安装均不向游戏安装模块。游戏所需代码与资源必须随 Addon 携带，或由用户加载相应 Mod；纯 Python 库也不会自动复制，仍需适配游戏解释器和 ModSDK。原生扩展及依赖外部安装步骤、系统环境的库不能直接用于游戏；包内 `.pyd/.dll/.so/.so.*（版本号）/.dylib` 会阻止构建和启动。
 
 ## 构建与日常开发
 
@@ -73,12 +75,14 @@ mcpy add --path "../shared-addon"
 
 ### 打包分发
 
-在项目根目录执行 `mcpy package`，会先构建项目及 Python 包／本地 Addon 依赖，再生成 `dist/<项目名>-<版本>.zip`。名称和版本读取 `pyproject.toml` 的 `[project]`；不需要配置 `target_dir`。
+在项目根目录执行 `mcpy package`，会组装项目及已识别的 Addon 依赖，再生成 `dist/<项目名>-<版本>.zip`；仅开发环境的包不会进入 ZIP。名称和版本读取 `pyproject.toml` 的 `[project]`；不需要配置 `target_dir`。
 
 Addon ZIP 内为 `<项目名>_bp/`、`<项目名>_rp/`（仅包含实际构建出的包）；地图 ZIP 根目录直接包含存档数据、行为包、资源包及世界包配置。地图默认保留独立包，使用 `mcpy package --merge`（或 `-m`）按构建规则合并依赖资源。构建产物中的空目录会保留。
 
 重复打包成功后会替换同名 ZIP；失败时保留已有 ZIP，临时文件自动清理。
 
+`publish` 向 PyPI 发布 Python 分发包，与游戏 ZIP 分发不同。本地测试可配置多个独立 Addon，游戏不会解析 Python 依赖图；构建成功不保证兼容，发布前应检查产物并在游戏中验证加载日志。
+
 ## 游戏启动与排查
 
 通常不需要手动指定游戏路径。mcpywrap 会优先查找 MC Studio 登记的安装，必要时搜索固定磁盘中的标准下载目录，并跳过不完整的引擎版本。
@@ -146,7 +150,7 @@ mcpy --project D:\tests\server stop --session <id> --json
 也可以下载仓库 ZIP，将完整的 `skills/mcpywrap` 文件夹复制到对应 Agent 的技能目录。
 无需从源码安装 Python 项目；CLI 和 Skill 分别安装，`pip/uv install` 不会自动注册 Skill。
 两端使用跨平台 `scripts/bootstrap.py` 安装或复用各自的 CLI，Windows 也可用 `bootstrap.ps1`。脚本分别报告本机与远端能力；Skill、CLI 与 Windows 服务需要分别检查，Git／可编辑安装可能缺少登录组件。
-局域网流程请使用 mcpywrap 0.3.6 或更高版本，可从 `v0.3.6` 标签安装配套 Skill。实际能力仍以脚本检测为准；更新 Skill 不会自动更新两端 CLI。
+推荐使用 mcpywrap 0.3.7 或更高版本，并从 `v0.3.7` 标签安装配套 Skill，以获得依赖边界提示与校验。实际能力仍以脚本检测为准；更新 Skill 不会自动更新两端 CLI。
 
 安装后可直接描述任务：
 

mcpywrap-0.3.7/docs/local-dependencies.md

@@ -0,0 +1,41 @@
+# 复用本地 Addon
+
+已有的 Addon 可以直接作为依赖，不需要先初始化或安装。
+
+```powershell
+mcpy add --path "../shared-addon"
+mcpy remove --path "../shared-addon"
+```
+
+请选择 Addon 根目录，例如：
+
+```text
+shared-addon/
+  behavior_pack/manifest.json
+  resource_pack/manifest.json
+```
+
+可以只有行为包或资源包；目录名也支持工具识别的 `BehaviorPack*`、`ResourcePack*` 等名称。
+不支持直接引用单个包目录、地图、普通源码目录，或同一 Addon 中多个同类型包。
+
+引用保存在 `tool.mcpywrap.local_dependencies`，相对路径以声明它的项目为基准。
+移除引用不会删除源目录。已有 mcpywrap 项目的子依赖会一并解析；循环依赖或失效路径会报错。
+
+`mcpy add "package-name>=1.0"` 在 mcpy 工具环境安装包。只有能从本地安装来源解析出有效 Addon 的内容参与组装；
+普通 Python 包或未识别到 Addon 内容的 wheel 标记为“仅开发环境”，不会复制 `site-packages`。
+本地路径不会自动转换为可分发的包依赖；共享项目时需同步引用目录。
+本地引用的包依赖未安装时，按警告显式安装；版本约束与环境标记检查的是工具 Python，不代表游戏兼容性。
+
+测试和正式游戏都使用游戏内置 Python，不读取 `dependencies`，不自动安装或加载其他 Mod。
+需要的纯 Python 代码及资源必须包含在 Addon 中，并适配游戏解释器、标准库及 ModSDK。
+游戏包内的 `.pyd`、`.dll`、`.so`、版本化 `.so.*`、`.dylib` 会在构建、打包、运行和编辑前报错，
+不再静默过滤；`dev` 检测到这类文件时保留原输出，移除问题文件后可恢复更新。
+开发工具可以使用二进制包，只要这些文件不放在游戏包中。依赖外部安装步骤或系统环境的库也不能直接用于游戏；
+当前校验不会分析所有 Python import，仍需检查 ZIP 内容和实际游戏日志。
+
+验收解包产物时，避免同时加载相同 manifest UUID 的源码包与产物，防止游戏选中旧内容。
+
+构建时主项目优先于依赖；同级依赖按声明顺序处理，后者覆盖重复内容。
+这不代表游戏运行时的资源包优先级。修改依赖声明后重启 `mcpy dev`。
+
+遇到结构错误先核对目录和清单；查看参数使用 `mcpy add --help`。

mcpywrap-0.3.7/mcpywrap/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""mcpywrap - 我的世界中国版 Addon 开发依赖、构建与游戏测试工具。"""
+
+__version__ = '0.3.7'

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/builders/dependency_manager.py

@@ -9,7 +9,8 @@ from urllib.request import url2pathname
 
 from packaging.requirements import Requirement, InvalidRequirement
 from packaging.utils import canonicalize_name
-from ..dependencies import DependencyError, addon_directories, canonical_path, declarations, read_project, resolve_path
+from ..dependencies import (DependencyError, DependencyStatus, addon_directories, canonical_path,
+                            declarations, read_project, resolve_path, validate_game_files)
 from .AddonsPack import AddonsPack
 
 
@@ -42,6 +43,8 @@ class DependencyManager:
         self.dependency_map = {}
         self.root_node = None
         self.warnings = []
+        self.errors = []
+        self.statuses = {}
         self._nodes, self._active, self._ordered = {}, [], []
 
     def find_dependency_path(self, package_name):
@@ -60,6 +63,10 @@ class DependencyManager:
             config.setdefault('project', {})['dependencies'] = dependencies
         root_id = re.sub(r'[^\w.-]', '_', project_name)[:60] + '_' + hashlib.sha256(canonical_path(project_path).encode('utf-8')).hexdigest()[:12]
         root = DependencyNode(project_name, AddonsPack(root_id, project_path, is_origin=True))
+        folders = [root.addon_pack.behavior_pack_dir, root.addon_pack.resource_pack_dir]
+        if config.get('tool', {}).get('mcpywrap', {}).get('project_type') == 'map':
+            folders = [Path(project_path) / name for name in ('behavior_packs', 'resource_packs')]
+        validate_game_files(project_path, folders)
         self.root_node = root
         key = canonical_path(project_path)
         self._nodes[key] = root
@@ -67,8 +74,8 @@ class DependencyManager:
         self._process(root, config)
         self._active.pop()
         self.dependency_map = {canonical_path(n.addon_pack.path): n.addon_pack for n in self._ordered}
-        if self.warnings and not allow_missing:
-            raise DependencyError('\n'.join(self.warnings))
+        if self.errors and not allow_missing:
+            raise DependencyError('\n'.join(self.errors))
         return root
 
     def _process(self, parent, config):
@@ -78,12 +85,14 @@ class DependencyManager:
                 if entry.kind == 'local':
                     path = str(resolve_path(source, entry.value))
                     self._visit(parent, path, Path(path).name)
+                    self._status(source, entry, 'addon')
                     continue
                 try:
                     requirement = Requirement(entry.value)
                 except InvalidRequirement as exc:
                     raise DependencyError(f'无效的 Python 包声明: {entry.value}') from exc
                 if requirement.marker and not requirement.marker.evaluate():
+                    self._status(source, entry, 'inactive', '当前工具 Python 环境不满足环境标记，未启用；不代表游戏兼容性。')
                     continue
                 try:
                     dist = metadata.distribution(requirement.name)
@@ -95,6 +104,7 @@ class DependencyManager:
                     continue
                 path = self.find_dependency_path(entry.value)
                 if not path:
+                    self._development_only(source, entry)
                     continue
                 direct = dist.read_text('direct_url.json')
                 if not Path(path).is_dir() and direct and 'dir_info' in json.loads(direct):
@@ -107,11 +117,30 @@ class DependencyManager:
                     for p in Path(path).iterdir())
                 if has_mcpy or looks_like_addon:
                     self._visit(parent, path, canonicalize_name(requirement.name))
+                    self._status(source, entry, 'addon')
+                else:
+                    self._development_only(source, entry)
             except (DependencyError, OSError, ValueError) as exc:
                 raise DependencyError(f'来源 {source}\n依赖 {entry.value!r}: {exc}') from exc
 
     def _missing(self, source, value, reason):
-        self.warnings.append(f'{source}: {value} {reason}；请显式执行 mcpy add "{value}"')
+        from ..dependencies import DependencyDeclaration
+        message = f'{source}: {value} {reason}；请显式执行 mcpy add "{value}"'
+        self.errors.append(message)
+        self.warnings.append(message)
+        self._status(source, DependencyDeclaration('package', value), 'unavailable', message)
+
+    def _status(self, source, entry, state, message=''):
+        self.statuses[(canonical_path(source), entry.kind, entry.value)] = DependencyStatus(state, message)
+
+    def status_for(self, source, entry):
+        return self.statuses[(canonical_path(source), entry.kind, entry.value)]
+
+    def _development_only(self, source, entry):
+        message = (f'来源 {source}，依赖 {entry.value!r}: 未识别到可组装内容；'
+                   '仅安装于工具环境，不会被打包或供游戏导入。')
+        self.warnings.append(message)
+        self._status(source, entry, 'development_only', message)
 
     def _visit(self, parent, path, name):
         key = canonical_path(path)
@@ -124,6 +153,7 @@ class DependencyManager:
         if config.get('tool', {}).get('mcpywrap', {}).get('project_type', 'addon') != 'addon':
             raise DependencyError(f'仅支持 Addon 目录依赖: {path}')
         folders = addon_directories(path)
+        validate_game_files(path, folders.values())
         suffix = hashlib.sha256(key.encode('utf-8')).hexdigest()[:12]
         safe_name = re.sub(r'[^\w.-]', '_', name)[:60] or 'addon'
         addon = AddonsPack(f'{safe_name}_{suffix}', path)

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/builders/project_builder.py

@@ -2,6 +2,7 @@
 import os
 import shutil
 from pathlib import Path
+from ..command_context import report_dependency_warnings
 from ..dependencies import DependencyError, DependencyService, addon_directories, read_project
 from .AddonsPack import AddonsPack
 from .MapPack import MapPack
@@ -30,6 +31,7 @@ class AddonProjectBuilder:
     def initialize(self):
         addon_directories(self.source_dir)
         self.dependency_manager = DependencyService(self.source_dir).resolve()
+        report_dependency_warnings(self.dependency_manager)
         self.dependency_tree = self.dependency_manager.root_node
         self.origin_addon = self.dependency_tree.addon_pack
         self.packs = list(self.dependency_manager.get_all_dependencies().values()) + [self.origin_addon]
@@ -60,6 +62,7 @@ class MapProjectBuilder:
     def build(self):
         try:
             manager = DependencyService(self.source_dir).resolve()
+            report_dependency_warnings(manager)
             packs = list(manager.get_all_dependencies().values())
             root = manager.root_node.addon_pack
             validate_target(self.target_dir, self.source_dir, packs + [root])

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/builders/watcher.py

@@ -4,7 +4,7 @@ import threading
 from pathlib import Path
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
-from ..dependencies import DependencyService
+from ..dependencies import DependencyService, is_native_file, validate_game_files
 from .AddonsPack import AddonsPack
 from .assembly import is_within, pack_files, rebuild_file, validate_target
 
@@ -17,7 +17,8 @@ class FileChangeHandler(FileSystemEventHandler):
         self.is_dependency, self.dependency_name = is_dependency, dependency_name
 
     def _should_ignore_path(self, path):
-        return is_within(path, self.target_dir) or self.addon_pack.should_exclude(path) and Path(path).name not in ('manifest.json', 'pack_manifest.json')
+        return is_within(path, self.target_dir) or (self.addon_pack.should_exclude(path)
+                and Path(path).name not in ('manifest.json', 'pack_manifest.json') and not is_native_file(path))
 
     def _process_event(self, event, event_type):
         if self._should_ignore_path(event.src_path):
@@ -117,18 +118,27 @@ class ProjectWatcher:
 
     def rebuild(self, kind, relative):
         with self.lock:
-            destination = Path(getattr(self.target_addon_pack, kind + '_pack_dir')) / relative
-            rebuild_file(self.packs, kind, relative, destination)
-            self.known_files.add((kind, relative))
-            return str(destination)
+            self.validate_sources()
+            return self._rebuild(kind, relative)
+
+    def _rebuild(self, kind, relative):
+        destination = Path(getattr(self.target_addon_pack, kind + '_pack_dir')) / relative
+        rebuild_file(self.packs, kind, relative, destination)
+        self.known_files.add((kind, relative))
+        return str(destination)
 
     def rebuild_all(self):
         with self.lock:
+            self.validate_sources()
             current = {(kind, rel) for p in self.packs for kind in ('behavior', 'resource') for rel in pack_files(p, kind)}
             for kind, relative in sorted(self.known_files | current):
-                self.rebuild(kind, relative)
+                self._rebuild(kind, relative)
             self.known_files = current
 
+    def validate_sources(self):
+        for pack in self.packs:
+            validate_game_files(pack.path, [pack.behavior_pack_dir, pack.resource_pack_dir])
+
     def start(self):
         self.multi_watcher.start_all()
 

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/command_context.py

@@ -6,7 +6,7 @@ import os
 import sys
 import tempfile
 import traceback
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 import click
@@ -19,6 +19,7 @@ class CommandContext:
     json_output: bool = False
     remote: str = None
     local: bool = False
+    warnings: list = field(default_factory=list)
 
 
 _context = contextvars.ContextVar('mcpy_context', default=None)
@@ -44,6 +45,17 @@ def human_interaction():
     return current is not None and not non_interactive() and not json_output()
 
 
+def report_dependency_warnings(manager):
+    """CLI 展示与 JSON 共用诊断；解析服务本身不进行输出。"""
+    current = _context.get()
+    for message in manager.warnings:
+        if current is not None:
+            if message in current.warnings:
+                continue
+            current.warnings.append(message)
+        click.secho(message, fg='yellow', err=True)
+
+
 @contextlib.contextmanager
 def project_scope(path):
     previous = _context.get()
@@ -117,6 +129,8 @@ class OperationGroup(click.Group):
                 data = {'ok': code == 0, 'error': None, 'hint': None}
                 if isinstance(result, dict):
                     data.update(result)
+                if state.warnings:
+                    data['warnings'] = list(dict.fromkeys([*data.get('warnings', []), *state.warnings]))
                 # ASCII JSON survives both GBK consoles and UTF-8 subprocess pipes losslessly.
                 click.echo(json.dumps(data, ensure_ascii=True), file=output)
             elif code:

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/commands/add_cmd.py

@@ -1,8 +1,6 @@
 """添加 Python 包或本地 Addon 目录依赖。"""
-import os
-from pathlib import Path
 import click
-from ..command_context import OperationCommand, project_dir as current_project, non_interactive, require_project
+from ..command_context import OperationCommand, project_dir as current_project, report_dependency_warnings
 from ..dependencies import DependencyDeclaration, DependencyError, DependencyService
 from .dependency_prompt import prompt_dependency, require_interactive
 
@@ -11,7 +9,7 @@ from .dependency_prompt import prompt_dependency, require_interactive
 @click.argument('package', required=False)
 @click.option('--path', 'local_path', help='直接引用本地 Addon 根目录，不安装目录')
 def add_cmd(package, local_path):
-    """添加依赖；不带参数时进入类型选择向导。"""
+    """添加依赖；包安装到 mcpy 工具环境，不安装到游戏。无参数进入向导。"""
     if package is not None and local_path is not None:
         raise click.UsageError('包名与 --path 不能同时使用')
     if not (current_project() / 'pyproject.toml').exists():
@@ -24,13 +22,15 @@ def add_cmd(package, local_path):
             entry = DependencyDeclaration('local' if local_path is not None else 'package', local_path if local_path is not None else package)
         service = DependencyService(str(current_project()))
         if entry.kind == 'local':
-            changed, warnings = service.add_local(entry.value)
-            for warning in warnings:
-                click.secho(warning, fg='yellow')
+            changed, _ = service.add_local(entry.value)
         else:
-            click.echo(f'正在安装 {entry.value}...')
+            click.echo(f'正在向 mcpy 工具环境安装 {entry.value}（非游戏环境）...')
             changed = service.add_package(entry.value)
+        manager = service.last_resolution
+        report_dependency_warnings(manager)
         click.secho('依赖已添加' if changed else '依赖已存在', fg='green')
-        return {'changed': changed, 'dependency': entry.value, 'source': entry.kind, 'warnings': warnings if entry.kind == 'local' else []}
+        return {'changed': changed, 'dependency': entry.value, 'source': entry.kind,
+                'classification': 'addon' if entry.kind == 'local' else manager.status_for(current_project(), entry).state,
+                'warnings': manager.warnings}
     except (DependencyError, OSError) as exc:
         raise click.ClickException(str(exc)) from exc

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/commands/build_cmd.py

@@ -33,12 +33,12 @@ def build_cmd(merge):
     target_dir = os.path.normpath(os.path.join(str(current_project()), target_dir))
 
     # 实际构建
-    if not build(str(current_project()), target_dir, force_merge=merge):
+    if not build(str(current_project()), target_dir, force_merge=merge, raise_errors=True):
         raise click.ClickException('构建失败')
     return {'output': target_dir}
 
     
-def build(source_dir, target_dir, force_merge: bool = False):
+def build(source_dir, target_dir, force_merge: bool = False, raise_errors=False):
     """
     执行项目构建
     
@@ -72,6 +72,8 @@ def build(source_dir, target_dir, force_merge: bool = False):
         click.secho('✅ 构建成功！项目已生成到目标目录。', fg="green")
         return True
     else:
+        if raise_errors:
+            raise click.ClickException(f'构建失败: {error}')
         click.secho(f'❌ 构建失败: ', fg="red", nl=False)
         click.secho(f'{error}', fg="bright_red")
         return False

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/commands/dependency_prompt.py

@@ -12,7 +12,7 @@ def require_interactive():
 
 
 def prompt_dependency():
-    kind = click.prompt('依赖类型：1 Python 包，2 本地 Addon 目录', type=click.Choice(['1', '2']), default='1')
+    kind = click.prompt('依赖类型：1 Python 包（安装于工具环境），2 本地 Addon 目录', type=click.Choice(['1', '2']), default='1')
     value = click.prompt('包名/版本约束' if kind == '1' else 'Addon 目录').strip()
     if kind == '1':
         try:

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/commands/edit_cmd.py

@@ -42,6 +42,9 @@ def open_edit(project_dir=None, engine_overrides=None, raise_errors=False):
     config = read_project(base_dir)
     project_name = config.get('project', {}).get('name', 'project')
     project_type = config.get('tool', {}).get('mcpywrap', {}).get('project_type', 'addon')
+    all_packs = _setup_dependencies(project_name, base_dir, raise_errors=raise_errors)
+    if all_packs is None:
+        return False
     try:
         engine = discover_engines(base_dir, engine_overrides).require_engine()
         require_resources(engine, 'editor')
@@ -53,9 +56,6 @@ def open_edit(project_dir=None, engine_overrides=None, raise_errors=False):
             raise
         click.echo(str(exc))
         return False
-    all_packs = _setup_dependencies(project_name, base_dir)
-    if all_packs is None:
-        return False
     studio_config_path = os.path.join(base_dir, 'studio.json')
     addon_packs_dirs = []
     for pack in all_packs:

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/commands/init_cmd.py

@@ -1,6 +1,6 @@
 """初始化项目：向导与显式参数使用同一服务。"""
 import click
-from ..command_context import OperationCommand, project_dir, non_interactive
+from ..command_context import OperationCommand, project_dir, non_interactive, report_dependency_warnings
 from ..project_init import initialize_project, detect_project
 from ..dependencies import DependencyService
 from .dependency_prompt import prompt_dependency
@@ -33,10 +33,9 @@ def init():
     while click.confirm('是否添加依赖？', default=False):
         entry = prompt_dependency()
         if entry.kind == 'local':
-            _, warnings = service.add_local(entry.value)
-            for warning in warnings:
-                click.echo(warning, err=True)
+            service.add_local(entry.value)
         else:
             service.add_package(entry.value)
+        report_dependency_warnings(service.last_resolution)
     click.echo('项目已初始化；使用 mod 生成脚本、modsdk 安装 SDK、sync --install 安装项目。')
     return result

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/commands/modsdk_cmd.py

@@ -9,7 +9,7 @@ from ..minecraft.netease_modsdk import get_available_versions, download_and_inst
 @click.option('--version', help='安装指定版本')
 @click.option('--latest', is_flag=True, help='显式选择最新版本')
 def modsdk_cmd(list_versions, version, latest):
-    """管理网易 ModSDK；非交互必须指定操作。"""
+    """在工具环境管理网易 ModSDK，不安装到游戏；非交互必须指定操作。"""
     if sum((list_versions, bool(version), latest)) > 1:
         raise click.UsageError('--list、--version、--latest 不能同时使用')
     if not any((list_versions, version, latest)) and non_interactive():

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/commands/package_cmd.py

@@ -15,7 +15,7 @@ from ..builders.project_builder import AddonProjectBuilder, MapProjectBuilder
 @click.command(cls=OperationCommand)
 @click.option('--merge', '-m', is_flag=True, help='强制合并所有资源文件（仅地图项目）')
 def package_cmd(merge):
-    """构建并打包可直接用于《我的世界》中国版市场发布的压缩包。"""
+    """组装 Addon/地图并生成分发 ZIP；游戏兼容性需实际测试。"""
     if not config_exists():
         raise click.ClickException('未找到配置文件。请先运行 `mcpy init` 初始化项目。')
 

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/commands/run_cmd.py

@@ -97,7 +97,7 @@ def _generate_new_instance_config(base_dir, project_name):
     
     return level_id, config_path
 
-def _setup_dependencies(project_name, base_dir, raise_errors=False):
+def _setup_dependencies(project_name, base_dir, raise_errors=False, report=None):
     """设置项目依赖"""
     from ..dependencies import DependencyService, DependencyError, addon_directories, read_project
     try:
@@ -106,6 +106,12 @@ def _setup_dependencies(project_name, base_dir, raise_errors=False):
         if project_type == 'addon':
             addon_directories(base_dir)
         manager = DependencyService(base_dir).resolve()
+        from ..command_context import report_dependency_warnings
+        if report is None:
+            report_dependency_warnings(manager)
+        else:
+            for message in manager.warnings:
+                report(message)
         packs = list(manager.get_all_dependencies().values())
         if project_type == 'addon':
             packs.append(manager.root_node.addon_pack)
@@ -407,7 +413,7 @@ def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach
         return
 
     # 设置依赖
-    all_packs = _setup_dependencies(project_name, base_dir)
+    all_packs = _setup_dependencies(project_name, base_dir, raise_errors=True)
     if all_packs is None:
         raise click.ClickException('依赖校验失败')
     auth_context = None

{mcpywrap-0.3.6 → mcpywrap-0.3.7}/mcpywrap/commands/sync_cmd.py

@@ -9,7 +9,7 @@ from ..dependencies import read_project, write_project
 @click.command(cls=OperationCommand)
 @click.option('--install', is_flag=True, help='同时在当前工具环境中可编辑安装项目')
 def sync_cmd(install):
-    """同步包配置；--install 显式安装项目。"""
+    """同步包配置；--install 安装到 mcpy 工具环境，不安装到游戏。"""
     require_project()
     return sync_project(project_dir(), install)