mcpywrap-core 0.6.2__tar.gz → 0.6.4__tar.gz

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpywrap-core
-Version: 0.6.2
+Version: 0.6.4
 Summary: Shared mcpy project dependency, build and runtime logic
 Author-email: boybook <boybook@easecation.net>
 License-Expression: MIT

mcpywrap_core-0.6.4/mcpywrap_core/_version.py

@@ -0,0 +1 @@
+__version__ = '0.6.4'

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/api.py

@@ -16,19 +16,19 @@ class Core:
 
     def describe(self):
         return {'core_api': CORE_API, 'host_api': HOST_API, 'version': __version__,
-                'operations': list(OPERATIONS), 'capabilities': self.host.capabilities()}
+                'operations': list(OPERATIONS), 'capabilities': {**self.host.capabilities(), 'unbundled-dependencies': True}}
 
     def execute(self, operation, project, **options):
         """Execute or raise the original structured error; never invoke another core."""
         if operation not in OPERATIONS:
             raise ValueError('未知工程操作：' + str(operation))
-        allowed = OPTIONS[operation] if operation in OPTIONS else {'resolve': set(), 'build': {'merge'}, 'package': {'merge'},
-                   'sync': {'install', 'migrate_windows_lock'}}[operation]
+        allowed = OPTIONS[operation] if operation in OPTIONS else {'resolve': {'bundled_only'}, 'build': {'merge'}, 'package': {'merge'},
+                   'sync': {'install', 'migrate_windows_lock', 'bundled_only'}}[operation]
         if set(options) - allowed or (operation not in OPTIONS and any(type(value) is not bool for value in options.values())):
             raise ValueError('无效的工程操作参数')
         if operation in OPTIONS:
             for name,value in options.items():
-                valid = (type(value) is bool if name=='effective' else
+                valid = (type(value) is bool if name in ('effective', 'unbundled') else
                          isinstance(value,(list,tuple)) and all(isinstance(item,str) for item in value) if name=='args' else
                          value is None or isinstance(value,str))
                 if not valid: raise ValueError('无效的工程操作参数：'+name)
@@ -45,10 +45,10 @@ class Core:
                 result = execute(operation, project, options)
             elif operation == 'resolve':
                 from .dependencies import DependencyService
-                manager = DependencyService(project).resolve()
+                manager = DependencyService(project).resolve(purpose="release" if options.get("bundled_only") else "runtime")
                 result = {'project': str(project), 'dependencies': [
                     {'name': pack.pkg_name, 'path': str(pack.path)}
-                    for pack in manager.get_all_dependencies().values()], 'warnings': manager.warnings}
+                    for pack in manager.get_all_dependencies().values()], 'warnings': manager.warnings, 'dependency_selection': manager.selection()}
             elif operation == 'build':
                 from .operations.build import build_project
                 result = build_project(project, **options)

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/builders/assembly.py

@@ -84,6 +84,20 @@ def rebuild_file(packs, kind, relative, destination):
             shutil.copy2(source, destination)
 
 
+def validate_unbundled_overrides(packs):
+    owners = {}
+    for pack in packs:
+        for relative in pack_files(pack, 'behavior'):
+            if not relative.endswith('.py'):
+                continue
+            module = relative[:-len('/__init__.py')] if relative.endswith('/__init__.py') else relative[:-3]
+            key = module.casefold()
+            for previous in owners.get(key, []):
+                if getattr(previous, 'unbundled', False) != getattr(pack, 'unbundled', False):
+                    raise DependencyError('unbundled 依赖不能覆盖随发布的 Python 模块: ' + relative + '\n来源: ' + str(previous.path) + ' / ' + str(pack.path))
+            owners.setdefault(key, []).append(pack)
+
+
 def assemble_addon(packs, target_pack):
     for kind in ('behavior', 'resource'):
         target = getattr(target_pack, kind + '_pack_dir')

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/builders/dependency_manager.py

@@ -71,6 +71,9 @@ class DependencyManager:
         self._git_sources = {}
         self.collect_errors = False
         self.has_git_projects = False
+        self.purpose = "runtime"
+        self.edges = []
+        self.excluded = []
 
     def find_dependency_path(self, package_name):
         try:
@@ -80,8 +83,10 @@ class DependencyManager:
         direct = dist.read_text('direct_url.json')
         return _local_url(json.loads(direct).get('url', '')) if direct else None
 
-    def build_dependency_tree(self, project_name, project_path, dependencies=None, *, config=None, allow_missing=False, git_lock=None, collect_errors=False):
+    def build_dependency_tree(self, project_name, project_path, dependencies=None, *, config=None, allow_missing=False, git_lock=None, collect_errors=False, purpose="runtime"):
         self.__init__()
+        from ..dependencies import validate_purpose
+        self.purpose = validate_purpose(purpose)
         self.collect_errors = collect_errors
         project_path = str(Path(project_path).resolve())
         if git_lock is not None:
@@ -101,18 +106,39 @@ class DependencyManager:
         self._active.append(key)
         self._process(root, config)
         self._active.pop()
+        self.bundled_nodes = {id(root)}
+        pending = [root]
+        while pending:
+            current = pending.pop()
+            for owner, child, unbundled in self.edges:
+                if owner is current and not unbundled and id(child) not in self.bundled_nodes:
+                    self.bundled_nodes.add(id(child))
+                    pending.append(child)
+        for node in self._ordered:
+            node.unbundled = id(node) not in self.bundled_nodes
+            node.addon_pack.unbundled = node.unbundled
         self.dependency_map = {canonical_path(n.addon_pack.path): n.addon_pack for n in self._ordered}
         if self.errors and not (allow_missing or collect_errors):
             raise DependencyError('\n'.join(self.errors))
         return root
 
     def _process(self, parent, config):
+        local_paths = {}
         for entry in declarations(config):
             source = parent.addon_pack.path
+            if entry.unbundled and (parent is not self.root_node or self.purpose == 'release'):
+                self.excluded.append({'source': str(source), 'dependency': entry.value, 'unbundled': True,
+                                      'reason': 'unbundled' if parent is self.root_node else 'dependency_unbundled'})
+                self._status(source, entry, 'excluded', 'unbundled 依赖不进入 build/package，也不向消费者传递')
+                continue
             try:
                 if entry.kind == 'local':
                     path = str(resolve_path(source, entry.value))
-                    self._visit(parent, path, Path(path).name)
+                    key = canonical_path(path)
+                    if key in local_paths and local_paths[key] != entry.unbundled:
+                        raise DependencyError('同一目录的 unbundled 设置冲突: ' + entry.value)
+                    local_paths[key] = entry.unbundled
+                    self._visit(parent, path, Path(path).name, unbundled=entry.unbundled)
                     self._status(source, entry, 'addon')
                     continue
                 try:
@@ -153,14 +179,18 @@ class DependencyManager:
                 if not self.collect_errors:
                     raise DependencyError(message) from exc
                 self.errors.append(message)
-        from ..git_projects import resolve_projects
+        from ..git_projects import resolve_projects, declarations as git_declarations
+        for entry in git_declarations(parent.addon_pack.path, config):
+            if entry.get('unbundled', False) and (parent is not self.root_node or self.purpose == 'release'):
+                self.excluded.append({'source': str(parent.addon_pack.path), 'dependency': entry['name'], 'unbundled': True,
+                                      'reason': 'unbundled' if parent is self.root_node else 'dependency_unbundled'})
         try:
             projects = resolve_projects(parent.addon_pack.path, config,
                                         self._git_locks.get(str(Path(parent.addon_pack.path).resolve())),
-                                        source_records=self._git_sources)
+                                        source_records=self._git_sources, purpose=self.purpose if parent is self.root_node else "release")
             for entry, path, info in projects:
                 self.has_git_projects = True
-                self._visit(parent, str(path), entry['name'])
+                self._visit(parent, str(path), entry['name'], unbundled=entry.get('unbundled', False))
         except (DependencyError, OSError, ValueError) as exc:
             if not self.collect_errors:
                 raise
@@ -185,7 +215,7 @@ class DependencyManager:
         self.warnings.append(message)
         self._status(source, entry, 'development_only', message)
 
-    def _visit(self, parent, path, name, source_kind='local'):
+    def _visit(self, parent, path, name, source_kind='local', unbundled=False):
         key = canonical_path(path)
         if key in self._active:
             raise DependencyError('循环依赖: ' + ' -> '.join(self._active + [key]))
@@ -193,6 +223,7 @@ class DependencyManager:
             if source_kind == 'local' and self._nodes[key].source['kind'] == 'package':
                 self._nodes[key].source['kind'] = 'local'
             parent.add_child(self._nodes[key])
+            self.edges.append((parent, self._nodes[key], unbundled))
             return
         config = read_project(path)
         if config.get('tool', {}).get('mcpywrap', {}).get('project_type', 'addon') != 'addon':
@@ -211,6 +242,7 @@ class DependencyManager:
         node = DependencyNode(name, addon, parent, source=source)
         self._nodes[key] = node
         parent.add_child(node)
+        self.edges.append((parent, node, unbundled))
         self._active.append(key)
         config = read_project(path)
         try:
@@ -220,6 +252,27 @@ class DependencyManager:
             self._active.pop()
         self._ordered.append(node)
 
+    def selection(self):
+        from collections import deque
+        paths = {(id(self.root_node), False): [self.root_node.name]}
+        pending = deque([(self.root_node, False)])
+        outgoing = {}
+        for parent, child, unbundled in self.edges:
+            outgoing.setdefault(id(parent), []).append((child, unbundled))
+        while pending:
+            parent, inherited = pending.popleft()
+            for child, unbundled in outgoing.get(id(parent), []):
+                effective = inherited or unbundled
+                key = (id(child), effective)
+                if key not in paths:
+                    paths[key] = paths[(id(parent), inherited)] + [child.name]
+                    pending.append((child, effective))
+        return {'purpose': self.purpose, 'includes_unbundled': self.purpose == 'runtime',
+                'dependencies': [{'name': node.name, 'path': str(node.addon_pack.path),
+                                  'unbundled': node.unbundled, 'included_in_release': not node.unbundled,
+                                  'via': [paths[(id(node), value)] for value in (False, True) if (id(node), value) in paths]} for node in self._ordered],
+                'excluded': self.excluded}
+
     def get_all_dependencies(self):
         return self.dependency_map
 

mcpywrap_core-0.6.4/mcpywrap_core/builders/output_lock.py

@@ -0,0 +1,46 @@
+"""A dev watcher owns its output until stopped; builds cannot overwrite it."""
+from contextlib import contextmanager
+from functools import wraps
+from pathlib import Path
+import hashlib
+import tempfile
+
+from ..dependencies import canonical_path, DependencyError
+from ..utils.locks import directory_lock
+
+
+class OutputLease:
+    def __init__(self, target):
+        self.target = canonical_path(target)
+        self.active = True
+
+    @contextmanager
+    def use(self, target):
+        if not self.active or canonical_path(target) != self.target:
+            raise DependencyError('构建输出占用凭据无效，请重启 dev')
+        yield self
+
+
+@contextmanager
+def output_lease(target):
+    key = hashlib.sha256(canonical_path(target).encode('utf-8')).hexdigest()
+    with directory_lock(Path(tempfile.gettempdir())/'mcpy-output-locks'/key, reentrant=True):
+        lease = OutputLease(target)
+        try:
+            yield lease
+        finally:
+            lease.active = False
+
+
+def locked_output(method):
+    @wraps(method)
+    def wrapped(self):
+        try:
+            if self.target_dir is None:
+                return method(self)
+            lease = getattr(self, 'output_lease', None)
+            with lease.use(self.target_dir) if lease else output_lease(self.target_dir):
+                return method(self)
+        except (ValueError, OSError) as exc:
+            return False, str(exc)
+    return wrapped

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/builders/project_builder.py

@@ -11,6 +11,7 @@ from .MapPack import MapPack
 from .assembly import assemble_addon, validate_target, is_within, pack_files, rebuild_file
 from ..code_libraries import prepare_libraries
 from ..utils.paths import is_link
+from .output_lock import locked_output
 
 
 def _replace_with_retry(source, target):
@@ -39,7 +40,7 @@ def _clear_directory(directory):
 
 
 class AddonProjectBuilder:
-    def __init__(self, source_dir, target_dir, include_dependencies=True, *, resolved=None, stable_layout=False):
+    def __init__(self, source_dir, target_dir, include_dependencies=True, *, resolved=None, stable_layout=False, purpose="release", output_lease=None):
         self.source_dir = str(Path(source_dir).resolve())
         self.requested_target = Path(target_dir).absolute() if target_dir else None
         self.target_dir = str(Path(target_dir).resolve()) if target_dir else None
@@ -47,6 +48,9 @@ class AddonProjectBuilder:
         self.project_name = self.config.get('project', {}).get('name', 'current_project')
         self.include_dependencies = include_dependencies
         self.resolved = resolved
+        from ..dependencies import validate_purpose
+        self.purpose = validate_purpose(purpose)
+        self.output_lease = output_lease
         self.stable_layout = stable_layout
 
     def initialize(self):
@@ -60,12 +64,16 @@ class AddonProjectBuilder:
             config.setdefault('project', {})['dependencies'] = []
             config.setdefault('tool', {}).setdefault('mcpywrap', {})['local_dependencies'] = []
             config['tool']['mcpywrap']['git_dependencies'] = []
-        self.dependency_manager = self.resolved or DependencyService(self.source_dir).resolve(config)
+        self.dependency_manager = self.resolved or DependencyService(self.source_dir).resolve(config, purpose=self.purpose)
+        from ..dependencies import require_resolution
+        require_resolution(self.dependency_manager, self.source_dir, self.purpose)
         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]
         prepare_libraries(self.packs)
+        from .assembly import validate_unbundled_overrides
+        validate_unbundled_overrides(self.packs)
         validate_target(self.target_dir, self.source_dir, self.packs)
         if is_link(self.target_dir):
             raise DependencyError('构建目标不能是目录链接')
@@ -77,6 +85,7 @@ class AddonProjectBuilder:
             setattr(self.target_addon, kind + '_pack_dir', str(Path(self.target_dir) / name))
         return True
 
+    @locked_output
     def build(self):
         try:
             from ..runtime.deployment import check_build_target
@@ -125,19 +134,25 @@ class AddonProjectBuilder:
 
 
 class MapProjectBuilder:
-    def __init__(self, source_dir, target_dir, merge=False):
+    def __init__(self, source_dir, target_dir, merge=False, *, purpose="release", resolved=None, output_lease=None):
         self.source_dir = str(Path(source_dir).resolve())
         self.requested_target = Path(target_dir).absolute() if target_dir else None
         self.target_dir = str(Path(target_dir).resolve()) if target_dir else None
         self.merge = merge
+        self.purpose, self.resolved = purpose, resolved
+        self.output_lease = output_lease
 
+    @locked_output
     def build(self):
         try:
             if self.requested_target is not None and is_link(self.requested_target):
                 raise DependencyError('构建目标不能是目录链接')
             from ..runtime.deployment import check_build_target
             check_build_target(self.source_dir, self.target_dir)
-            manager = DependencyService(self.source_dir).resolve()
+            manager = self.resolved or DependencyService(self.source_dir).resolve(purpose=self.purpose)
+            from ..dependencies import require_resolution
+            require_resolution(manager, self.source_dir, self.purpose)
+            self.manager = manager
             report_dependency_warnings(manager)
             packs = list(manager.get_all_dependencies().values())
             root = manager.root_node.addon_pack

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/builders/watcher.py

@@ -94,17 +94,20 @@ class MultiWatcher:
 
 
 class ProjectWatcher:
-    def __init__(self, source_dir, target_dir, callback=None):
+    def __init__(self, source_dir, target_dir, callback=None, *, output_lease=None):
         self.source_dir, self.target_dir = os.path.abspath(source_dir), os.path.abspath(target_dir)
         self.callback = callback
         self.multi_watcher = MultiWatcher()
         self.lock = threading.RLock()
         self.known_files = set()
+        self.output_lease = output_lease
 
     def setup_from_config(self, project_name, dependencies=None):
         self.dependency_manager = DependencyService(self.source_dir).resolve()
         self.main_addon_pack = self.dependency_manager.root_node.addon_pack
         self.packs = list(self.dependency_manager.get_all_dependencies().values()) + [self.main_addon_pack]
+        from .assembly import validate_unbundled_overrides
+        validate_unbundled_overrides(self.packs)
         self.has_libraries = prepare_libraries(self.packs)
         self.has_libraries = self.has_libraries or self.dependency_manager.has_git_projects
         validate_target(self.target_dir, self.source_dir, self.packs)
@@ -147,11 +150,13 @@ class ProjectWatcher:
     def _build_libraries(self):
         # 带固定代码库的项目使用原子完整组装，不能绕过摘要或目标冲突校验。
         from .project_builder import AddonProjectBuilder
-        success, error = AddonProjectBuilder(self.source_dir, self.target_dir).build()
+        success, error = AddonProjectBuilder(self.source_dir, self.target_dir, purpose="runtime", output_lease=self.output_lease).build()
         if not success:
             raise ValueError(error)
 
     def validate_sources(self):
+        from .assembly import validate_unbundled_overrides
+        validate_unbundled_overrides(self.packs)
         for pack in self.packs:
             validate_game_files(pack.path, [pack.behavior_pack_dir, pack.resource_pack_dir])
 

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/cli.py

@@ -8,7 +8,7 @@ from .command_context import OperationGroup, configure_context
 COMMANDS = {
     name: (name + '_cmd', name + '_cmd') for name in
     ('host', 'skill', 'modsdk', 'init', 'add', 'remove', 'build', 'dev', 'package', 'publish',
-     'mod', 'run', 'connect', 'edit', 'ui', 'doctor', 'engine', 'sync', 'serve', 'record', 'script', 'deployment')
+     'mod', 'run', 'deps', 'connect', 'edit', 'ui', 'doctor', 'engine', 'sync', 'serve', 'record', 'script', 'deployment')
 }
 COMMANDS.update({name: ('session_cmd', name + '_cmd') for name in ('status', 'logs', 'stop', 'restart')})
 COMMANDS.update({name: ('runtime_cmd', name + '_cmd') for name in ('runtime', 'py', 'reload')})

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/command_context.py

@@ -88,7 +88,7 @@ def require_project():
 
 def restart_handoff(result, previous):
     if not isinstance(result,dict) or not previous: return result
-    current=result.get('session')
+    current=result.get('replacement_session',result.get('session'))
     if current and current!=previous:
         result=dict(result,previous_session=previous,session_changed=True)
         message='会话已更换；后续日志、截图和调试请使用 --session '+current+'。旧会话记录仍保留。'
@@ -226,7 +226,7 @@ class OperationGroup(click.Group):
                     if result.get('hint'):
                         click.echo(result['hint'])
                     for key, value in result.items():
-                        if key not in ('ok', 'error', 'hint') and value is not None:
+                        if key not in ('ok', 'error', 'hint', 'dependency_selection') and value is not None:
                             click.echo(f'{key}: {value}')
         finally:
             _context.reset(token)

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/commands/add_cmd.py

@@ -1,13 +1,15 @@
 """添加 Python 包或本地 Addon 目录依赖。"""
 import click
 from ..command_context import OperationCommand, project_dir as current_project, report_dependency_warnings
-from ..dependencies import DependencyDeclaration, DependencyError, DependencyService
+from ..dependencies import DependencyDeclaration, DependencyError, DependencyService, canonical_path, resolve_path, included_in_release
 from .dependency_prompt import prompt_dependency, require_interactive, PromptDependency
 from ..framework_presets import FRAMEWORK_PRESETS
+from ..dependency_feedback import report_unbundled
 
 
 @click.command(cls=OperationCommand)
 @click.argument('package', required=False)
+@click.option('--unbundled/--bundled', default=None, help='不随 build/package 打包；新依赖默认打包，重复添加时省略则保留原设置')
 @click.option('--path', 'local_path', help='直接引用本地 Addon 根目录，不安装目录')
 @click.option('--qumod', is_flag=True, help='添加并同步已验证版本的 QuMod 外部代码库')
 @click.option('--framework', type=click.Choice(list(FRAMEWORK_PRESETS)), help='添加已注册框架预设')
@@ -19,11 +21,15 @@ from ..framework_presets import FRAMEWORK_PRESETS
 @click.option('--target', help='代码依赖在行为包内的安装目录')
 @click.option('--script-dir', help='框架所属脚本目录；唯一入口自动识别，无入口默认 MyScript')
 @click.option('--source', '--qumod-source', 'preset_source', help='预设源码来源名称，例如 github/gitee')
-def add_cmd(package, local_path, qumod, framework, git_url, git_ref, dep_name, subdir, kind, target, script_dir, preset_source):
+def add_cmd(package, local_path, qumod, framework, git_url, git_ref, dep_name, subdir, kind, target, script_dir, preset_source, unbundled=None):
     """添加依赖；包安装到 mcpy 工具环境，不安装到游戏。无参数进入向导。"""
     if sum((package is not None, local_path is not None, qumod, framework is not None, git_url is not None)) > 1:
         raise click.UsageError('请选择一种依赖来源：包名、--path、--git、--framework 或 --qumod')
+    if unbundled is not None and package is not None:
+        raise click.UsageError('--unbundled/--bundled 只用于游戏依赖；Python 包仍安装在工具环境')
     preset = 'qumod' if qumod else framework
+    if unbundled is True and preset:
+        raise click.UsageError('框架快捷入口保持正式依赖；开发辅助代码请使用 add --git --unbundled')
     if (script_dir or preset_source) and not preset:
         raise click.UsageError('--script-dir/--source 需要框架预设')
     if (git_ref or dep_name or subdir is not None or kind is not None or target) and not git_url:
@@ -33,9 +39,10 @@ def add_cmd(package, local_path, qumod, framework, git_url, git_ref, dep_name, s
     try:
         service = DependencyService(str(current_project()))
         if git_url:
-            result = service.add_git(git_url, ref=git_ref, name=dep_name, subdir=subdir, kind=kind, target=target)
+            result = service.add_git(git_url, ref=git_ref, name=dep_name, subdir=subdir, kind=kind, target=target, unbundled=unbundled)
             from ..consumer_prepare import guidance
             result['preparation'] = guidance(current_project())
+            report_unbundled(result)
             return result
         if preset:
             entry = PromptDependency('framework', preset, {'script_dir': script_dir, 'source': preset_source})
@@ -46,11 +53,14 @@ def add_cmd(package, local_path, qumod, framework, git_url, git_ref, dep_name, s
             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 == 'git':
-            result = service.add_git(entry.value, **entry.options)
+            result = service.add_git(entry.value, **entry.options, unbundled=unbundled)
             from ..consumer_prepare import guidance
             result['preparation'] = guidance(current_project())
+            report_unbundled(result)
             return result
         if entry.kind == 'framework':
+            if unbundled is True:
+                raise click.UsageError('框架快捷入口保持正式依赖；开发辅助代码请使用 add --git --unbundled')
             click.echo('正在准备框架外部依赖（固定提交，不安装到工具 Python 环境）...')
             result = service.add_framework(entry.value, **entry.options)
             for warning in result['warnings']:
@@ -58,10 +68,17 @@ def add_cmd(package, local_path, qumod, framework, git_url, git_ref, dep_name, s
             click.secho('框架已准备；其他开发者克隆后执行 mcpy sync 即可恢复。', fg='green')
             from ..consumer_prepare import guidance
             result['preparation'] = guidance(current_project())
+            report_unbundled(result)
             return result
+        previous_unbundled = None
         if entry.kind == 'local':
-            changed, _ = service.add_local(entry.value)
+            previous = next((item for item in service.list() if item.kind == 'local' and canonical_path(resolve_path(current_project(), item.value)) == canonical_path(resolve_path(current_project(), entry.value))), None)
+            previous_unbundled = previous.unbundled if previous else None
+            changed, _ = service.add_local(entry.value, unbundled=unbundled)
+            entry = next(item for item in service.list() if item.kind == "local" and canonical_path(resolve_path(current_project(), item.value)) == canonical_path(resolve_path(current_project(), entry.value)))
         else:
+            if unbundled is not None:
+                raise click.UsageError('--unbundled/--bundled 只用于游戏依赖')
             click.echo(f'正在向 mcpy 工具环境安装 {entry.value}（非游戏环境）...')
             changed = service.add_package(entry.value)
         manager = service.last_resolution
@@ -69,7 +86,10 @@ def add_cmd(package, local_path, qumod, framework, git_url, git_ref, dep_name, s
         click.secho('依赖已添加' if changed else '依赖已存在', fg='green')
         from ..consumer_prepare import guidance
         preparation = guidance(current_project(), resolved=manager)
-        return {'changed': changed, 'dependency': entry.value, 'source': entry.kind, 'preparation': preparation,
+        release_inclusion = included_in_release(manager, resolve_path(current_project(), entry.value)) if entry.kind == 'local' else None
+        if entry.kind == 'local':
+            report_unbundled({'unbundled': entry.unbundled, 'previous_unbundled': previous_unbundled, 'included_in_release': release_inclusion})
+        return {'unbundled': entry.unbundled if entry.kind == 'local' else None, 'previous_unbundled': previous_unbundled, 'included_in_release': release_inclusion, 'changed': changed, 'dependency': entry.value, 'source': entry.kind, 'preparation': preparation,
                 'classification': 'addon' if entry.kind == 'local' else manager.status_for(current_project(), entry).state,
                 'warnings': manager.warnings}
     except (DependencyError, OSError) as exc:

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/commands/build_cmd.py

@@ -11,5 +11,7 @@ def build_cmd(merge):
     """构建为 MCStudio 工程"""
     require_project()
     result = Core().execute('build', project_dir(), merge=merge)
+    from ..dependency_feedback import report_selection
+    report_selection(result.get('dependency_selection'))
     click.secho('✅ 构建成功！项目已生成到目标目录。', fg='green')
     return result

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/commands/dependency_prompt.py

@@ -36,6 +36,8 @@ def prompt_dependency():
             options['subdir'] = click.prompt('源码子目录', default='.').strip()
             options['target'] = click.prompt('行为包内安装目录').strip()
         return PromptDependency('git', url, options)
+    if kind == '2':
+        click.echo('默认添加正式依赖，随 build/package 发布；仅本地开发使用可执行 add --path <目录> --unbundled。')
     value = click.prompt('包名/版本约束' if kind == '1' else 'Addon 目录').strip()
     if kind == '1':
         try:

mcpywrap_core-0.6.4/mcpywrap_core/commands/deps_cmd.py

@@ -0,0 +1,27 @@
+"""Inspect the selected dependency graph without installing or running hooks."""
+import click
+from ..command_context import OperationCommand, project_dir, require_project, json_output, report_dependency_warnings
+from ..dependencies import DependencyService
+from ..dependency_feedback import report_selection
+from ..utils.console import echo
+
+
+@click.command(cls=OperationCommand)
+@click.option('--bundled-only', is_flag=True, help='预览 build/package 的正式依赖图；默认预览 dev/run')
+def deps_cmd(bundled_only):
+    """只读查看依赖用途、发布状态和引用链；不执行准备或安装。"""
+    require_project()
+    manager = DependencyService(project_dir()).resolve(purpose='release' if bundled_only else 'runtime')
+    report_dependency_warnings(manager)
+    return present_selection(manager.selection())
+
+
+def present_selection(result):
+    report_selection(result)
+    for item in result['dependencies']:
+        echo('%s [unbundled=%s / %s]' % (item['name'], str(item['unbundled']).lower(), '随发布' if item['included_in_release'] else '不随发布'))
+        for chain in item['via']:
+            echo('  ' + ' → '.join(chain))
+    for item in result['excluded']:
+        echo('%s [已排除：%s]' % (item['dependency'], '不进入发布' if item['reason'] == 'unbundled' else '依赖自身的 unbundled 引用不传递'))
+    return result if json_output() else None

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/commands/dev_cmd.py

@@ -66,43 +66,48 @@ def dev_cmd(reload_session):
         project_name = config.get('project', {}).get('name', 'current_project')
         dependencies_list = config.get('project', {}).get('dependencies', [])
         
-        # 实际构建
-        from ..project_scripts import before, configured, validate_build
-        from ..consumer_prepare import PreparationPlan
-        plan = PreparationPlan(source_dir)
-        if configured(source_dir):
-            validate_build(source_dir, target_dir, resolved=plan.manager)
-        with before(source_dir, 'before_build', plan=plan):
-            suc = build(source_dir, target_dir, resolved=plan.manager)
-        if not suc:
-            click.secho("❌ 初始构建失败", fg="red")
-            raise click.ClickException('无法启动开发监控')
+        from ..builders.output_lock import output_lease
+        with output_lease(target_dir) as lease:
+            # 实际构建
+            from ..project_scripts import before, configured, validate_build
+            from ..consumer_prepare import PreparationPlan
+            plan = PreparationPlan(source_dir)
+            from ..dependency_feedback import report_selection
+            report_selection(plan.manager.selection())
+            if configured(source_dir):
+                validate_build(source_dir, target_dir, resolved=plan.manager, purpose="runtime")
+            with before(source_dir, 'before_build', plan=plan):
+                suc = build(source_dir, target_dir, resolved=plan.manager, purpose="runtime", output_lease=lease)
+            if not suc:
+                click.secho("❌ 初始构建失败", fg="red")
+                raise click.ClickException('无法启动开发监控')
 
-        click.secho(f"🔍 开始监控代码变化，路径: ", fg="bright_blue", nl=False)
-        click.secho(f"{source_dir}", fg="bright_cyan")
+            click.secho(f"🔍 开始监控代码变化，路径: ", fg="bright_blue", nl=False)
+            click.secho(f"{source_dir}", fg="bright_cyan")
         
-        if plan.enabled:
-            click.echo('初次资源准备已完成；dev 后续只同步包内文件，原始素材修改需要重新构建并应用。')
+            if plan.enabled:
+                click.echo('初次资源准备已完成；dev 后续只同步包内文件，原始素材修改需要重新构建并应用。')
 
-        # 创建项目监视器
-        project_watcher = ProjectWatcher(source_dir, target_dir, file_change_callback)
+            # 创建项目监视器
+            project_watcher = ProjectWatcher(source_dir, target_dir, file_change_callback, output_lease=lease)
         
-        # 设置监视器
-        dep_count = project_watcher.setup_from_config(project_name, dependencies_list)
+            # 设置监视器
+            dep_count = project_watcher.setup_from_config(project_name, dependencies_list)
         
-        if dep_count > 0:
-            click.secho(f"✅ 找到并监控 {dep_count} 个依赖包", fg="green")
+            if dep_count > 0:
+                click.secho(f"✅ 找到并监控 {dep_count} 个依赖包", fg="green")
         
-        # 启动监视
-        project_watcher.start()
-        try:
-            click.secho("👀 监控中... 按 Ctrl+C 停止", fg="bright_magenta")
-            while True:
-                time.sleep(1)
-        except KeyboardInterrupt:
-            project_watcher.stop()
-            click.secho("🛑 监控已停止", fg="bright_yellow")
-            raise
+            # 启动监视
+            project_watcher.start()
+            try:
+                click.secho("👀 监控中... 按 Ctrl+C 停止", fg="bright_magenta")
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                click.secho("🛑 监控已停止", fg="bright_yellow")
+                raise
+            finally:
+                project_watcher.stop()
     else:
         click.secho('❌ 暂未支持: 当前仅支持Addons项目的构建', fg="red")
         raise click.ClickException('无法启动开发监控')

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.4}/mcpywrap_core/commands/package_cmd.py

@@ -12,5 +12,7 @@ def package_cmd(merge):
     """组装 Addon/地图并生成分发 ZIP；游戏兼容性需实际测试。"""
     require_project()
     result = Core().execute('package', project_dir(), merge=merge)
+    from ..dependency_feedback import report_selection
+    report_selection(result.get('dependency_selection'))
     click.secho('✅ 打包成功！分发文件路径: ' + result['artifact'], fg='green')
     return result