mcpywrap 0.1.0__py3-none-any.whl

mcpywrap/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""mcpywrap - 将 Python 3 代码转换为 Python 2 代码的工具"""
+
+__version__ = '0.1.0'

mcpywrap/__main__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+"""
+mcpywrap 命令行工具的入口点
+"""
+
+from .cli import cli
+
+def main():
+    """主函数，作为 CLI 入口点"""
+    cli()
+
+if __name__ == "__main__":
+    main()

mcpywrap/builders/AddonsPack.py

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+
+import os
+import shutil
+import click
+from .file_handler import ensure_dir, try_merge_file
+
+
+# Python 包管理和其他应该忽略的文件和目录
+EXCLUDED_PATTERNS = [
+    # Python 包管理
+    ".egg-info",
+    "__pycache__",
+    ".pyc",
+    ".pyo",
+    ".pyd",
+    ".so",
+    ".dll",
+    ".eggs",
+    ".pytest_cache",
+    ".tox",
+    ".coverage",
+    ".coverage.*",
+    "htmlcov",
+    # 版本控制
+    ".git",
+    ".hg",
+    ".svn",
+    ".bzr",
+    # 其他临时文件
+    ".DS_Store",
+    "Thumbs.db"
+]
+
+MANIFEST_FILES = [
+    "manifest.json",
+    "pack_manifest.json"
+]
+
+
+class AddonsPack(object):
+
+    pkg_name: str
+    path: str
+    is_origin: bool
+    behavior_pack_dir: str
+    resource_pack_dir: str
+
+    def __init__(self, pkg_name, path, is_origin=False):
+        self.pkg_name = pkg_name
+        self.path = path
+        self.is_origin = is_origin
+        self.behavior_pack_dir = None
+        self.resource_pack_dir = None
+        # 进入此目录，查找内部的行为包和资源包的路径
+        os.chdir(self.path)
+        for item in os.listdir(self.path):
+            item_path = os.path.join(self.path, item)
+            if os.path.isdir(item_path):
+                if item.startswith("behavior_pack") or item.startswith("BehaviorPack"):
+                    self.behavior_pack_dir = item_path
+                elif item.startswith("resource_pack") or item.startswith("ResourcePack"):
+                    self.resource_pack_dir = item_path
+        if not self.behavior_pack_dir:
+            self.behavior_pack_dir = os.path.join(self.path, "behavior_pack")
+        if not self.resource_pack_dir:
+            self.resource_pack_dir = os.path.join(self.path, "resource_pack")
+
+    def should_exclude(self, path):
+        """判断文件或目录是否应该被排除"""
+        for pattern in EXCLUDED_PATTERNS:
+            if pattern in path:
+                return True
+        # 得到文件名
+        filename = os.path.basename(path)
+        if not self.is_origin and filename in MANIFEST_FILES:
+            return True
+        return False
+
+    def copy_behavior_to(self, target_dir: str):
+        """复制行为包和资源包到目标目录"""
+        if self.behavior_pack_dir:
+            target_path = os.path.join(target_dir, os.path.basename(self.behavior_pack_dir))
+            os.makedirs(target_path, exist_ok=True)
+
+            # 使用自定义复制函数而不是shutil.copytree
+            for root, dirs, files in os.walk(self.behavior_pack_dir):
+                # 过滤掉应该排除的目录
+                dirs[:] = [d for d in dirs if not self.should_exclude(os.path.join(root, d))]
+
+                # 计算相对路径
+                rel_path = os.path.relpath(root, self.behavior_pack_dir)
+                # 计算目标目录
+                target_root = os.path.join(target_path, rel_path) if rel_path != '.' else target_path
+                ensure_dir(target_root)
+
+                # 复制文件
+                for file in files:
+                    src_file = os.path.join(root, file)
+                    if not self.should_exclude(src_file):
+                        dest_file = os.path.join(target_root, file)
+                        # 如果是Python文件，检查并添加编码声明
+                        if file.endswith('.py'):
+                            self._copy_with_encoding_check(src_file, dest_file)
+                        else:
+                            shutil.copy2(src_file, dest_file)
+
+    def copy_resource_to(self, target_dir: str):
+        """复制资源包到目标目录"""
+        if self.resource_pack_dir:
+            target_path = os.path.join(target_dir, os.path.basename(self.resource_pack_dir))
+            os.makedirs(target_path, exist_ok=True)
+
+            # 使用自定义复制函数而不是shutil.copytree
+            for root, dirs, files in os.walk(self.resource_pack_dir):
+                # 过滤掉应该排除的目录
+                dirs[:] = [d for d in dirs if not self.should_exclude(os.path.join(root, d))]
+
+                # 计算相对路径
+                rel_path = os.path.relpath(root, self.resource_pack_dir)
+                # 计算目标目录
+                target_root = os.path.join(target_path, rel_path) if rel_path != '.' else target_path
+                ensure_dir(target_root)
+
+                # 复制文件
+                for file in files:
+                    src_file = os.path.join(root, file)
+                    if not self.should_exclude(src_file):
+                        dest_file = os.path.join(target_root, file)
+                        # 如果是Python文件，检查并添加编码声明
+                        if file.endswith('.py'):
+                            self._copy_with_encoding_check(src_file, dest_file)
+                        else:
+                            shutil.copy2(src_file, dest_file)
+
+    def merge_behavior_into(self, target_behavior_dir: str):
+        """合并行为包到目标行为包目录"""
+        if self.behavior_pack_dir:
+            for root, dirs, files in os.walk(self.behavior_pack_dir):
+                # 过滤掉应该排除的目录
+                dirs[:] = [d for d in dirs if not self.should_exclude(os.path.join(root, d))]
+
+                # 计算相对路径
+                rel_path = os.path.relpath(root, self.behavior_pack_dir)
+                # 计算目标目录
+                target_root = os.path.join(target_behavior_dir, rel_path) if rel_path != '.' else target_behavior_dir
+                ensure_dir(target_root)
+
+                # 复制文件
+                for file in files:
+                    src_file = os.path.join(root, file)
+                    if self.should_exclude(src_file):
+                        continue
+
+                    dest_file = os.path.join(target_root, file)
+
+                    if file.endswith('.py'):  # 如果是Python文件，直接无脑覆盖
+                        self._copy_with_encoding_check(src_file, dest_file)
+                    elif os.path.exists(dest_file):  # 如果文件已存在，尝试合并
+                        suc, reason = try_merge_file(src_file, dest_file)
+                        if not suc:
+                            click.secho(f"❌ 未处理的文件冲突: {src_file} -> {dest_file} {reason}", fg="red")
+                    else:
+                        shutil.copy2(src_file, dest_file)
+
+    def merge_resource_into(self, target_resource_dir: str):
+        """合并资源包到目标资源包目录"""
+        if self.resource_pack_dir:
+            for root, dirs, files in os.walk(self.resource_pack_dir):
+                # 过滤掉应该排除的目录
+                dirs[:] = [d for d in dirs if not self.should_exclude(os.path.join(root, d))]
+
+                # 计算相对路径
+                rel_path = os.path.relpath(root, self.resource_pack_dir)
+                # 计算目标目录
+                target_root = os.path.join(target_resource_dir, rel_path) if rel_path != '.' else target_resource_dir
+                ensure_dir(target_root)
+
+                # 复制文件
+                for file in files:
+                    src_file = os.path.join(root, file)
+                    if self.should_exclude(src_file):
+                        continue
+
+                    dest_file = os.path.join(target_root, file)
+                    # 处理文件冲突
+                    if file.endswith('.py'):
+                        self._copy_with_encoding_check(src_file, dest_file)
+                    elif os.path.exists(dest_file):
+                        suc, reason = try_merge_file(src_file, dest_file)
+                        if not suc:
+                            click.secho(f"⚠️ 警告: 文件合并异常 {src_file} -> {dest_file} {reason}", fg="yellow")
+                            # 如果是Python文件，检查并添加编码声明
+                            if file.endswith('.py'):
+                                self._copy_with_encoding_check(src_file, dest_file)
+                            else:
+                                shutil.copy2(src_file, dest_file)
+                    else:
+                        shutil.copy2(src_file, dest_file)
+
+    def _copy_with_encoding_check(self, src_file, dest_file):
+        """复制Python文件，并检查添加编码声明"""
+        try:
+            with open(src_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            # 检查是否有编码声明
+            has_coding = False
+            first_line = content.splitlines()[0] if content.splitlines() else ""
+            if "# -*- coding: utf-8 -*-" in first_line or "# coding: utf-8" in first_line:
+                has_coding = True
+
+            # 如果没有编码声明，则添加
+            if not has_coding:
+                content = "# -*- coding: utf-8 -*-\n" + content
+
+            # 写入目标文件
+            with open(dest_file, 'w', encoding='utf-8') as f:
+                f.write(content)
+
+            # 复制文件元数据
+            shutil.copystat(src_file, dest_file)
+        except Exception as e:
+            click.secho(f"⚠️ 添加编码声明时出错: {src_file} -> {dest_file}: {str(e)}", fg="yellow")
+            # 如果出错，则直接复制
+            shutil.copy2(src_file, dest_file)

mcpywrap/builders/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+构建模块包，提供项目构建、文件处理和监控功能
+"""
+
+from .project_builder import build_project
+from .file_handler import process_file, is_python_file
+from .watcher import FileWatcher
+
+__all__ = ['build_project', 'process_file', 'is_python_file', 'FileWatcher']

mcpywrap/builders/file_handler.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+"""
+文件处理模块 - 负责单个文件的复制和转换
+"""
+
+import os
+import shutil
+
+from ..utils.py3to2_util import py3_to_2
+from ..utils.utils import ensure_dir, run_command
+from .file_merge import try_merge_file
+
+def is_python_file(file_path):
+    """判断是否为Python文件"""
+    return file_path.endswith('.py')
+
+def copy_file(src_path, dest_path):
+    """复制文件，确保目标目录存在"""
+    dest_dir = os.path.dirname(dest_path)
+    ensure_dir(dest_dir)
+    print(f"复制文件: {src_path} 到 {dest_path}")
+    shutil.copy2(src_path, dest_path)
+    return dest_path
+
+def convert_py3_to_py2(file_path):
+    """将某个Python文件转换为Python 2"""
+    try:
+        # 首先尝试使用直接的Python API调用
+        from lib3to2.main import main
+        # main函数接受包名和参数列表
+        # 第一个参数是包名 'lib3to2' (这是3to2所有修复器的位置)
+        # 第二个参数是命令行参数列表
+        exit_code = main('lib3to2.fixes', ['-w', '-n', '--no-diffs', file_path, '--nofix=metaclass'])
+        # exit_code = py3_to_2(file_path)
+        return exit_code == 0, "转换完成" if exit_code == 0 else f"转换失败，错误代码: {exit_code}"
+    except Exception as e:
+        # 如果直接调用失败，则尝试命令行方式（作为备选）
+        try:
+            # 方法1：直接命令行调用
+            success, output = run_command(["3to2", "-w", "-n", file_path])
+            if not success:
+                # 方法2：使用shell=True参数
+                success, output = run_command(["3to2", "-w", "-n", file_path], shell=True)
+            
+            return success, output
+        except Exception as cmd_e:
+            return False, f"Python API调用失败: {str(e)}\n命令行调用也失败: {str(cmd_e)}"
+
+def process_file(src_path, source_dir, target_dir, is_dependency=False, dependency_name=None):
+    """处理单个文件（复制并根据文件类型处理）"""
+    # 计算相对路径和目标路径
+    rel_path = os.path.relpath(src_path, source_dir)
+    
+    # 如果是依赖项，需要特殊处理目标路径
+    if is_dependency:
+        # 确定是属于行为包还是资源包
+        if "behavior_pack" in src_path.lower() or "behaviorpack" in src_path.lower():
+            # 在路径中定位behavior_pack部分
+            parts = src_path.split(os.sep)
+            for i, part in enumerate(parts):
+                if "behavior_pack" in part.lower() or "behaviorpack" in part.lower():
+                    # 获取behavior_pack后的相对路径
+                    sub_path = os.path.join(*parts[i+1:])
+                    # 目标路径应该是behavior_pack目录
+                    for item in os.listdir(target_dir):
+                        if "behavior_pack" in item.lower() or "behaviorpack" in item.lower():
+                            dest_path = os.path.join(target_dir, item, sub_path)
+                            break
+                    else:
+                        # 如果找不到behavior_pack目录，创建一个
+                        dest_path = os.path.join(target_dir, "behavior_pack", sub_path)
+                    break
+        elif "resource_pack" in src_path.lower() or "resourcepack" in src_path.lower():
+            # 在路径中定位resource_pack部分
+            parts = src_path.split(os.sep)
+            for i, part in enumerate(parts):
+                if "resource_pack" in part.lower() or "resourcepack" in part.lower():
+                    # 获取resource_pack后的相对路径
+                    sub_path = os.path.join(*parts[i+1:])
+                    # 目标路径应该是resource_pack目录
+                    for item in os.listdir(target_dir):
+                        if "resource_pack" in item.lower() or "resourcepack" in item.lower():
+                            dest_path = os.path.join(target_dir, item, sub_path)
+                            break
+                    else:
+                        # 如果找不到resource_pack目录，创建一个
+                        dest_path = os.path.join(target_dir, "resource_pack", sub_path)
+                    break
+        else:
+            # 如果不在行为包或资源包中，忽略该文件
+            return False, "不在行为包或资源包中的文件将被忽略", None
+    else:
+        dest_path = os.path.join(target_dir, rel_path)
+
+    # 检查目标文件是否已存在，如果存在且来自依赖，尝试合并
+    if is_dependency and os.path.exists(dest_path):
+        suc, reason = try_merge_file(src_path, dest_path)
+        if not suc:
+            # 如果合并失败或有冲突，直接返回
+            msg = f"文件合并失败或存在冲突" if reason is None else reason
+            return False, msg, dest_path
+    else:
+        # 复制文件
+        copy_file(src_path, dest_path)
+
+    # 如果是Python文件，进行转换
+    if is_python_file(src_path):
+        success, output = convert_py3_to_py2(dest_path)
+        return success, output, dest_path
+
+    # 如果是其他类型文件，直接返回成功
+    return True, "", dest_path

mcpywrap/builders/file_merge.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+import os
+import shutil
+
+
+def try_merge_file(source_file, target_file) -> tuple[bool, str]:
+    """合并两个JSON文件的内容"""
+    # 如果是py文件，直接复制即可
+    if source_file.endswith('.py'):
+        # 直接复制
+        shutil.copy2(source_file, target_file)
+        return True, f"成功复制 {os.path.basename(source_file)}"
+    else:
+        # 读取源文件内容
+        with open(source_file, 'r', encoding='utf-8') as f:
+            source_content = f.read()
+
+        # 读取目标文件内容
+        with open(target_file, 'r', encoding='utf-8') as f:
+            target_content = f.read()
+
+        # 合并两个JSON对象
+        try:
+            source_json = eval(source_content)
+            target_json = eval(target_content)
+            merged_json = _merge_dicts(target_json, source_json)
+
+            # 写入合并后的内容到目标文件
+            with open(target_file, 'w', encoding='utf-8') as f:
+                f.write(str(merged_json))
+
+            return True, f"成功合并 {os.path.basename(source_file)} 到 {os.path.basename(target_file)}"
+        except Exception as e:
+            return False, f"合并失败: {str(e)}"
+
+def _merge_dicts(dict1, dict2):
+    """递归合并两个字典"""
+    result = dict1.copy()
+    for key, value in dict2.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            # 递归合并嵌套字典
+            result[key] = _merge_dicts(result[key], value)
+        elif key in result and isinstance(result[key], list) and isinstance(value, list):
+            # 合并列表
+            result[key].extend(value)
+        else:
+            # 覆盖或添加新键
+            result[key] = value
+    return result

mcpywrap/builders/project_builder.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+"""
+项目构建模块 - 负责整个项目的构建过程
+"""
+
+import os
+import shutil
+import sys
+import json
+from pathlib import Path
+import click
+
+from ..utils.py3to2_util import py3_to_2
+from ..utils.utils import run_command
+from ..config import read_config, CONFIG_FILE
+from .AddonsPack import AddonsPack
+
+
+def clear_directory(directory):
+    """清空目录内容但保留目录本身"""
+    for item in os.listdir(directory):
+        item_path = os.path.join(directory, item)
+        if os.path.isdir(item_path):
+            shutil.rmtree(item_path)
+        else:
+            os.remove(item_path)
+
+def convert_project_py3_to_py2(directory):
+    """将整个项目中的Python文件转换为Python 2"""
+    try:
+        # 首先尝试使用直接的Python API调用
+        from lib3to2.main import main
+        # main函数接受包名和参数列表
+        # 第一个参数是包名 'lib3to2' (这是3to2所有修复器的位置)
+        # 第二个参数是命令行参数列表
+        exit_code = main('lib3to2.fixes', ['-w', '-n', '-j', '4', '--no-diffs', directory, '--nofix=metaclass'])
+        #exit_code = py3_to_2(directory)
+        return exit_code == 0, "转换完成" if exit_code == 0 else f"转换失败，错误代码: {exit_code}"
+    except Exception as e:
+        # 如果直接调用失败，则尝试命令行方式（作为备选）
+        try:
+            # 方法1：直接命令行调用
+            success, output = run_command(["3to2", "-w", "-n", directory])
+            if not success:
+                # 方法2：使用shell=True参数
+                success, output = run_command(["3to2", "-w", "-n", directory], shell=True)
+
+            return success, output
+        except Exception as cmd_e:
+            return False, f"Python API调用失败: {str(e)}\n命令行调用也失败: {str(cmd_e)}"
+
+def find_mcpywrap_dependencies(dependencies: list[str]) -> dict[str, AddonsPack]:
+    """
+    查找依赖包的真实路径，支持常规安装和 pip install -e（编辑安装）。
+    """
+    # 记录依赖包的路径
+    dep_paths = {}
+    # 得到site-packages路径
+    for site_package_dir in __import__('site').getsitepackages():
+        site_packages = Path(site_package_dir)
+        for dist_info in site_packages.glob("*.dist-info"):
+            # 读取METADATA文件获取真实包名
+            metadata_path = dist_info / "METADATA"
+            if metadata_path.exists():
+                pkg_name = None
+                with open(metadata_path, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        if line.startswith("Name:"):
+                            pkg_name = line.split(":", 1)[1].strip()
+                            break
+
+                if not pkg_name or pkg_name not in dependencies:
+                    continue
+
+                # 处理direct_url.json获取包路径
+                direct_url_path = dist_info / "direct_url.json"
+                if direct_url_path.exists():
+                    with open(direct_url_path, 'r', encoding='utf-8') as f:
+                        direct_url = json.load(f)
+                        # 读取其中的url
+                        if "url" in direct_url:
+                            url = direct_url["url"]
+                            # 处理file://开头的路径
+                            if url.startswith("file:///"):
+                                # 移除file:/// 前缀
+                                if sys.platform == "win32":
+                                    # Windows 路径处理 (例如 file:///D:/path)
+                                    url = url[8:]  # 去除 file:///
+                                else:
+                                    url = "/" + url[8:]  # 保留根目录斜杠
+                                url = os.path.abspath(url)
+                            # 兼容处理旧格式 file://
+                            elif url.startswith("file://"):
+                                url = url[7:]
+                            # 对URL进行解码，处理%编码的特殊字符
+                            from urllib.parse import unquote
+                            url = unquote(url)
+                            url = os.path.abspath(url)
+
+                            # 确保路径格式一致
+                            if sys.platform == "win32":
+                                url = url.replace("\\", "/")
+
+                            dep_paths[pkg_name] = AddonsPack(pkg_name, url)
+                        else:
+                            click.secho(f"⚠️ 警告: {pkg_name} 的direct_url.json中没有url字段", fg="yellow")
+                else:
+                    click.secho(f"⚠️ 警告: {pkg_name} 没有找到direct_url.json文件", fg="yellow")
+
+    # 检查是否所有依赖都已找到
+    missing_deps = [dep for dep in dependencies if dep not in dep_paths]
+    if missing_deps:
+        click.secho(f"⚠️ 警告: 未找到以下依赖包: {', '.join(missing_deps)}", fg="yellow")
+
+    return dep_paths
+
+def build_project(source_dir, target_dir):
+    """
+    构建整个项目：
+    1. 复制所有项目文件
+    2. 复制并合并所有依赖项的文件
+    3. 转换所有Python文件
+    4. 报告冲突
+    """
+    # 先清空
+    clear_directory(target_dir)
+
+    # 复制项目文件
+    config = read_config(os.path.join(source_dir, CONFIG_FILE))
+    project_name = config.get('project', {}).get('name', 'current_project')
+    origin_addons = AddonsPack(project_name, source_dir, is_origin=True)
+
+    # 复制基础
+    origin_addons.copy_behavior_to(target_dir)
+    origin_addons.copy_resource_to(target_dir)
+
+    target_addons = AddonsPack(project_name, target_dir)
+
+    # 查找并处理所有mcpywrap依赖
+    dependencies_list = config.get('project', {}).get('dependencies', [])
+    dependencies = find_mcpywrap_dependencies(dependencies_list)
+    click.secho(f"✅ 找到 {len(dependencies)} 个依赖包", fg="green")
+    for dep in dependencies:
+        click.secho(f" 📦 {dep} → {dependencies[dep].path}", fg="green")
+    for origin, dep in dependencies.items():
+        if origin not in dependencies:
+            click.secho(f"⚠️ 警告: 找不到依赖包 {origin}", fg="yellow")
+            continue
+
+    for dep in dependencies:
+        dependencies[dep].merge_behavior_into(target_addons.behavior_pack_dir)
+        dependencies[dep].merge_resource_into(target_addons.resource_pack_dir)
+
+    # 转换Python文件
+    success, output = convert_project_py3_to_py2(target_dir)
+
+    return success, output

mcpywrap/builders/watcher.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+"""
+文件监控模块 - 负责监控文件变化并触发处理
+"""
+
+import os
+import time
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+from .file_handler import process_file, is_python_file
+
+class FileChangeHandler(FileSystemEventHandler):
+    """文件变化处理器"""
+    def __init__(self, source_dir, target_dir, callback=None, is_dependency=False, dependency_name=None):
+        self.source_dir = source_dir
+        self.target_dir = target_dir
+        self.last_event_time = 0
+        self.cooldown = 2  # 冷却时间（秒）
+        self.callback = callback
+        self.is_dependency = is_dependency  # 是否是依赖项目
+        self.dependency_name = dependency_name  # 依赖项目名称
+
+    def on_any_event(self, event):
+        # 检查路径是否有效
+        if not hasattr(event, 'src_path'):
+            return
+
+        src_path = event.src_path
+
+        # 忽略目录事件、隐藏文件和临时文件
+        if (event.is_directory or
+                os.path.basename(src_path).startswith('.') or
+                src_path.endswith('~') or
+                os.path.basename(src_path).startswith('.#') or
+                os.path.basename(src_path).endswith('.swp') or  # vim临时文件
+                os.path.basename(src_path).endswith('.tmp')):  # 其他临时文件
+            return
+
+        # 检查文件是否存在
+        if not os.path.exists(src_path):
+            return
+
+        current_time = time.time()
+        if current_time - self.last_event_time > self.cooldown:
+            self.last_event_time = current_time
+
+            # 处理文件变化
+            success, output, dest_path = process_file(
+                src_path,
+                self.source_dir,
+                self.target_dir,
+                is_dependency=self.is_dependency,
+                dependency_name=self.dependency_name
+            )
+
+            # 如果有回调函数，调用它
+            if self.callback and dest_path:  # 确保dest_path存在
+                is_py = is_python_file(src_path)
+                self.callback(src_path, dest_path, success, output, is_py, self.is_dependency, self.dependency_name)
+
+class FileWatcher:
+    """文件监控器"""
+    def __init__(self, source_dir, target_dir, callback=None, is_dependency=False, dependency_name=None):
+        self.source_dir = source_dir
+        self.target_dir = target_dir
+        self.observer = None
+        self.callback = callback
+        self.is_dependency = is_dependency
+        self.dependency_name = dependency_name
+        
+    def start(self):
+        """开始监控"""
+        event_handler = FileChangeHandler(
+            self.source_dir, 
+            self.target_dir,
+            self.callback,
+            self.is_dependency,
+            self.dependency_name
+        )
+        self.observer = Observer()
+        self.observer.schedule(event_handler, path=self.source_dir, recursive=True)
+        self.observer.start()
+        
+    def stop(self):
+        """停止监控"""
+        if self.observer:
+            self.observer.stop()
+            self.observer.join()
+
+class MultiWatcher:
+    """多项目文件监控器，用于同时监控主项目和依赖项目"""
+    def __init__(self):
+        self.watchers = []
+        
+    def add_watcher(self, watcher):
+        """添加一个监视器"""
+        self.watchers.append(watcher)
+        
+    def start_all(self):
+        """启动所有监视器"""
+        for watcher in self.watchers:
+            watcher.start()
+            
+    def stop_all(self):
+        """停止所有监视器"""
+        for watcher in self.watchers:
+            watcher.stop()