@agentunion/kite 1.3.1 → 1.4.0

package/kite_cli/core/dependency.py

@@ -0,0 +1,229 @@
+"""依赖管理 - 安装 Python/npm/Kite 模块依赖"""
+import subprocess
+import sys
+from pathlib import Path
+from kite_cli.core.tool_installer import ToolInstaller
+
+
+class DependencyInstaller:
+    """依赖安装器"""
+
+    @staticmethod
+    def install_python_deps(module_dir: Path, packages: list) -> bool:
+        """安装 Python 依赖到模块内的 .venv"""
+        if not packages:
+            return True
+
+        # 确保 Python 和 pip 已安装
+        if not ToolInstaller.ensure_tool("python"):
+            print("  [Error] Python 未安装且自动安装失败")
+            return False
+        if not ToolInstaller.ensure_tool("pip"):
+            print("  [Error] pip 未安装且自动安装失败")
+            return False
+
+        print(f"[Install] 安装 Python 依赖: {', '.join(packages)}")
+
+        venv_dir = module_dir / ".venv"
+
+        try:
+            # 创建虚拟环境
+            if not venv_dir.exists():
+                print("  创建虚拟环境...")
+                result = subprocess.run(
+                    [sys.executable, "-m", "venv", str(venv_dir)],
+                    capture_output=True,
+                    text=True,
+                    timeout=60
+                )
+                if result.returncode != 0:
+                    print(f"  [Error] 创建虚拟环境失败: {result.stderr}")
+                    return False
+
+            # 确定 pip 路径
+            if sys.platform == "win32":
+                pip_path = venv_dir / "Scripts" / "pip.exe"
+            else:
+                pip_path = venv_dir / "bin" / "pip"
+
+            # 安装依赖
+            print("  安装包...")
+            result = subprocess.run(
+                [str(pip_path), "install"] + packages,
+                capture_output=True,
+                text=True,
+                timeout=300
+            )
+
+            if result.returncode != 0:
+                print(f"  [Error] 安装失败: {result.stderr}")
+                return False
+
+            print("  [Done] Python 依赖安装完成")
+            return True
+
+        except Exception as e:
+            print(f"  [Error] 安装失败: {e}")
+            return False
+
+    @staticmethod
+    def install_npm_deps(module_dir: Path, packages: list) -> bool:
+        """安装 npm 依赖到模块内的 node_modules"""
+        if not packages:
+            return True
+
+        # 确保 npm 已安装
+        if not ToolInstaller.ensure_tool("npm"):
+            print("  [Error] npm 未安装且自动安装失败")
+            return False
+
+        print(f"[Install] 安装 npm 依赖: {', '.join(packages)}")
+
+        try:
+            # 检查是否有 package.json
+            package_json = module_dir / "package.json"
+            if not package_json.exists():
+                # 创建基础 package.json
+                import json
+                with open(package_json, "w") as f:
+                    json.dump({
+                        "name": module_dir.name,
+                        "version": "1.0.0",
+                        "dependencies": {}
+                    }, f, indent=2)
+
+            # 安装依赖
+            result = subprocess.run(
+                ["npm", "install"] + packages,
+                cwd=str(module_dir),
+                capture_output=True,
+                text=True,
+                timeout=300
+            )
+
+            if result.returncode != 0:
+                print(f"  [Error] 安装失败: {result.stderr}")
+                return False
+
+            print("  [Done] npm 依赖安装完成")
+            return True
+
+        except Exception as e:
+            print(f"  [Error] 安装失败: {e}")
+            return False
+
+    @staticmethod
+    def install_git_deps(module_dir: Path, repos: list) -> bool:
+        """安装 Git 依赖到模块内的 .git_deps"""
+        if not repos:
+            return True
+
+        # 确保 git 已安装
+        if not ToolInstaller.ensure_tool("git"):
+            print("  [Error] git 未安装且自动安装失败")
+            return False
+
+        print(f"[Install] 安装 Git 依赖: {', '.join(repos)}")
+
+        git_deps_dir = module_dir / ".git_deps"
+        git_deps_dir.mkdir(exist_ok=True)
+
+        try:
+            for repo_url in repos:
+                # 提取仓库名
+                repo_name = repo_url.rstrip('/').split('/')[-1]
+                if repo_name.endswith('.git'):
+                    repo_name = repo_name[:-4]
+
+                target_dir = git_deps_dir / repo_name
+
+                # 如果已存在，跳过
+                if target_dir.exists():
+                    print(f"  [Skip] {repo_name} 已存在")
+                    continue
+
+                print(f"  克隆 {repo_name}...")
+                result = subprocess.run(
+                    ["git", "clone", repo_url, str(target_dir)],
+                    capture_output=True,
+                    text=True,
+                    timeout=120
+                )
+
+                if result.returncode != 0:
+                    print(f"  [Error] 克隆失败: {result.stderr}")
+                    return False
+
+            print("  [Done] Git 依赖安装完成")
+            return True
+
+        except FileNotFoundError:
+            print("  [Error] git 命令未找到，请先安装 Git")
+            return False
+        except Exception as e:
+            print(f"  [Error] 安装失败: {e}")
+            return False
+
+    @staticmethod
+    def install_kite_deps(modules: list, location: str) -> bool:
+        """递归安装 Kite 模块依赖"""
+        if not modules:
+            return True
+
+        print(f"[Install] 安装 Kite 模块依赖: {', '.join(modules)}")
+
+        # 这里需要递归调用 kite install
+        # 为了避免循环导入，使用 subprocess
+        for module in modules:
+            print(f"  安装 {module}...")
+            try:
+                result = subprocess.run(
+                    [sys.executable, "-m", "kite_cli", "install", module, "-l", location, "-y"],
+                    capture_output=True,
+                    text=True,
+                    timeout=300
+                )
+                if result.returncode != 0:
+                    print(f"  [Error] 安装 {module} 失败")
+                    return False
+            except Exception as e:
+                print(f"  [Error] 安装 {module} 失败: {e}")
+                return False
+
+        print("  [Done] Kite 模块依赖安装完成")
+        return True
+
+    @classmethod
+    def install_all_deps(cls, module_dir: Path, module_data: dict, location: str, skip_deps: bool = False) -> bool:
+        """安装所有依赖"""
+        if skip_deps:
+            print("[Warning] 跳过依赖安装 (--no-deps)")
+            return True
+
+        # 从 module.md 读取依赖
+        dependencies = module_data.get("dependencies", {})
+        if not dependencies:
+            print("[Info] 无依赖需要安装")
+            return True
+
+        # Python 依赖
+        python_deps = dependencies.get("python", [])
+        if python_deps and not cls.install_python_deps(module_dir, python_deps):
+            return False
+
+        # npm 依赖
+        npm_deps = dependencies.get("npm", [])
+        if npm_deps and not cls.install_npm_deps(module_dir, npm_deps):
+            return False
+
+        # Git 依赖
+        git_deps = dependencies.get("git", [])
+        if git_deps and not cls.install_git_deps(module_dir, git_deps):
+            return False
+
+        # Kite 模块依赖
+        kite_deps = dependencies.get("kite", [])
+        if kite_deps and not cls.install_kite_deps(kite_deps, location):
+            return False
+
+        return True

package/kite_cli/core/downloader.py

@@ -0,0 +1,209 @@
+"""下载器 - 从各平台下载模块（改进版，带详细错误提示）"""
+import subprocess
+import tempfile
+import shutil
+import zipfile
+from pathlib import Path
+from typing import Optional, Tuple
+from kite_cli.core.tool_installer import ToolInstaller
+
+
+class DownloadError(Exception):
+    """下载错误"""
+    pass
+
+
+class Downloader:
+    """从各平台下载模块"""
+
+    @staticmethod
+    def download_pypi(name: str, dest: Path, version: str = None) -> Tuple[Optional[Path], Optional[str]]:
+        """
+        从 PyPI 下载包
+        Args:
+            name: 包名
+            dest: 目标目录
+            version: 版本号(可选),如 "1.2.0"
+        返回: (下载路径, 错误信息)
+        """
+        # 确保 pip 已安装
+        if not ToolInstaller.ensure_tool("pip"):
+            return None, "pip 未安装且自动安装失败，请手动安装 Python 和 pip"
+
+        # 构建包名(带版本)
+        package_spec = f"{name}=={version}" if version else name
+
+        try:
+            dest.mkdir(parents=True, exist_ok=True)
+            result = subprocess.run(
+                ["pip", "download", package_spec, "--dest", str(dest), "--no-deps"],
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+
+            if result.returncode != 0:
+                # pip 命令执行失败
+                error_msg = result.stderr.strip() if result.stderr else result.stdout.strip()
+                if "Could not find" in error_msg or "No matching distribution" in error_msg:
+                    return None, f"PyPI 上未找到包 '{name}'"
+                elif "Network" in error_msg or "timeout" in error_msg.lower():
+                    return None, f"网络错误: 无法连接到 PyPI"
+                else:
+                    return None, f"pip 下载失败: {error_msg[:200]}"
+
+            # 查找下载的文件
+            files = list(dest.glob("*"))
+            if not files:
+                return None, "下载成功但未找到文件"
+
+            # 解压（.whl 或 .tar.gz）
+            downloaded_file = files[0]
+            extract_dir = dest / "extracted"
+            extract_dir.mkdir(exist_ok=True)
+
+            try:
+                # .whl 文件是 zip 格式
+                if downloaded_file.suffix == '.whl':
+                    with zipfile.ZipFile(downloaded_file, 'r') as zip_ref:
+                        zip_ref.extractall(extract_dir)
+                else:
+                    shutil.unpack_archive(downloaded_file, extract_dir)
+                return extract_dir, None
+            except Exception as e:
+                return None, f"解压失败: {str(e)}"
+
+        except FileNotFoundError:
+            return None, "pip 命令未找到，请先安装 Python 和 pip"
+        except subprocess.TimeoutExpired:
+            return None, "下载超时（60秒），请检查网络连接"
+        except Exception as e:
+            return None, f"未知错误: {str(e)}"
+
+    @staticmethod
+    def download_npm(name: str, dest: Path, version: str = None) -> Tuple[Optional[Path], Optional[str]]:
+        """
+        从 npm 下载包
+        Args:
+            name: 包名
+            dest: 目标目录
+            version: 版本号(可选),如 "1.2.0"
+        返回: (下载路径, 错误信息)
+        """
+        # 确保 npm 已安装
+        if not ToolInstaller.ensure_tool("npm"):
+            return None, "npm 未安装且自动安装失败，请手动安装 Node.js 和 npm"
+
+        # 构建包名(带版本)
+        package_spec = f"{name}@{version}" if version else name
+
+        try:
+            dest.mkdir(parents=True, exist_ok=True)
+            result = subprocess.run(
+                ["npm", "pack", package_spec, "--pack-destination", str(dest)],
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+
+            if result.returncode != 0:
+                error_msg = result.stderr.strip() if result.stderr else result.stdout.strip()
+                if "404" in error_msg or "Not Found" in error_msg:
+                    return None, f"npm 上未找到包 '{name}'"
+                elif "network" in error_msg.lower() or "ETIMEDOUT" in error_msg:
+                    return None, "网络错误: 无法连接到 npm registry"
+                else:
+                    return None, f"npm 下载失败: {error_msg[:200]}"
+
+            # 查找 .tgz 文件
+            tgz_files = list(dest.glob("*.tgz"))
+            if not tgz_files:
+                return None, "下载成功但未找到 .tgz 文件"
+
+            tgz_file = tgz_files[0]
+            extract_dir = dest / "extracted"
+            extract_dir.mkdir(exist_ok=True)
+
+            try:
+                shutil.unpack_archive(tgz_file, extract_dir)
+                # npm pack 会创建 package/ 子目录
+                package_dir = extract_dir / "package"
+                if package_dir.exists():
+                    return package_dir, None
+                return extract_dir, None
+            except Exception as e:
+                return None, f"解压失败: {str(e)}"
+
+        except FileNotFoundError:
+            return None, "npm 命令未找到，请先安装 Node.js 和 npm"
+        except subprocess.TimeoutExpired:
+            return None, "下载超时（60秒），请检查网络连接"
+        except Exception as e:
+            return None, f"未知错误: {str(e)}"
+
+    @staticmethod
+    def download_git(url: str, dest: Path) -> Tuple[Optional[Path], Optional[str]]:
+        """
+        从 Git 克隆仓库
+        返回: (下载路径, 错误信息)
+        """
+        # 确保 git 已安装
+        if not ToolInstaller.ensure_tool("git"):
+            return None, "git 未安装且自动安装失败，请手动安装 Git"
+
+        try:
+            dest.mkdir(parents=True, exist_ok=True)
+            clone_dir = dest / "repo"
+            result = subprocess.run(
+                ["git", "clone", url, str(clone_dir)],
+                capture_output=True,
+                text=True,
+                timeout=120
+            )
+
+            if result.returncode != 0:
+                error_msg = result.stderr.strip() if result.stderr else result.stdout.strip()
+                if "not found" in error_msg.lower() or "does not exist" in error_msg.lower():
+                    return None, f"Git 仓库不存在: {url}"
+                elif "Authentication failed" in error_msg or "Permission denied" in error_msg:
+                    return None, "认证失败: 仓库可能是私有的或需要登录"
+                elif "network" in error_msg.lower() or "timeout" in error_msg.lower():
+                    return None, "网络错误: 无法连接到 Git 服务器"
+                else:
+                    return None, f"git clone 失败: {error_msg[:200]}"
+
+            if not clone_dir.exists():
+                return None, "克隆成功但目录不存在"
+
+            return clone_dir, None
+
+        except FileNotFoundError:
+            return None, "git 命令未找到，请先安装 Git"
+        except subprocess.TimeoutExpired:
+            return None, "克隆超时（120秒），仓库可能太大或网络太慢"
+        except Exception as e:
+            return None, f"未知错误: {str(e)}"
+
+    @staticmethod
+    def download_local(path: str, dest: Path) -> Tuple[Optional[Path], Optional[str]]:
+        """
+        从本地路径复制
+        返回: (下载路径, 错误信息)
+        """
+        try:
+            src = Path(path).resolve()
+            if not src.exists():
+                return None, f"本地路径不存在: {path}"
+
+            if not src.is_dir():
+                return None, f"路径不是目录: {path}"
+
+            dest.mkdir(parents=True, exist_ok=True)
+            copy_dir = dest / "local"
+            shutil.copytree(src, copy_dir)
+            return copy_dir, None
+
+        except PermissionError:
+            return None, f"权限不足: 无法读取 {path}"
+        except Exception as e:
+            return None, f"复制失败: {str(e)}"

package/kite_cli/core/install_info.py

@@ -0,0 +1,40 @@
+"""安装信息记录"""
+import json
+from datetime import datetime
+from pathlib import Path
+from kite_cli import __version__
+
+
+def record_install_info(module_dir: Path, source_info: dict, module_data: dict, location: str):
+    """记录安装信息到 .kite_install.json"""
+    install_info = {
+        "name": module_data.get("name"),
+        "version": module_data.get("version", "unknown"),
+        "source": source_info,
+        "installed_at": datetime.utcnow().isoformat() + "Z",
+        "installed_by": f"kite-cli@{__version__}",
+        "location": location,
+        "dependencies": module_data.get("dependencies", {})
+    }
+
+    install_info_path = module_dir / ".kite_install.json"
+    try:
+        with open(install_info_path, "w", encoding="utf-8") as f:
+            json.dump(install_info, f, indent=2, ensure_ascii=False)
+        return True
+    except Exception as e:
+        print(f"[Warning] 记录安装信息失败: {e}")
+        return False
+
+
+def read_install_info(module_dir: Path) -> dict:
+    """读取安装信息"""
+    install_info_path = module_dir / ".kite_install.json"
+    if not install_info_path.exists():
+        return None
+
+    try:
+        with open(install_info_path, encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None