@agentunion/kite 1.3.2 → 1.5.0

package/kite_cli/core/checker.py

@@ -0,0 +1,142 @@
+"""平台检查器 - 检查模块在各平台是否存在"""
+import subprocess
+import json
+from typing import Optional, List, Dict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+class PlatformChecker:
+    """检查模块在各平台的存在性"""
+
+    @staticmethod
+    def check_pypi(name: str) -> Optional[Dict]:
+        """检查 PyPI 是否存在该包"""
+        try:
+            # 使用 pip index versions
+            result = subprocess.run(
+                ["pip", "index", "versions", name],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            if result.returncode == 0 and "Available versions:" in result.stdout:
+                # 解析版本
+                lines = result.stdout.split("\n")
+                for line in lines:
+                    if "Available versions:" in line:
+                        versions_str = line.split(":", 1)[1].strip()
+                        versions = [v.strip() for v in versions_str.split(",")]
+                        return {
+                            "platform": "pypi",
+                            "name": name,
+                            "versions": versions,
+                            "latest": versions[0] if versions else None
+                        }
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+        return None
+
+    @staticmethod
+    def check_npm(name: str) -> Optional[Dict]:
+        """检查 npm 是否存在该包"""
+        try:
+            # 获取所有版本
+            result = subprocess.run(
+                ["npm", "view", name, "versions", "--json"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                shell=True  # Windows 兼容性
+            )
+            if result.returncode == 0:
+                try:
+                    versions_data = json.loads(result.stdout)
+                    # versions 可能是字符串(单版本)或列表(多版本)
+                    if isinstance(versions_data, str):
+                        versions = [versions_data]
+                    elif isinstance(versions_data, list):
+                        versions = versions_data
+                    else:
+                        versions = []
+
+                    if versions:
+                        return {
+                            "platform": "npm",
+                            "name": name,
+                            "versions": versions,
+                            "latest": versions[-1] if versions else None  # npm 返回的版本是升序
+                        }
+                except json.JSONDecodeError:
+                    # 降级到只获取最新版本
+                    result = subprocess.run(
+                        ["npm", "view", name, "version"],
+                        capture_output=True,
+                        text=True,
+                        timeout=10,
+                        shell=True
+                    )
+                    if result.returncode == 0:
+                        version = result.stdout.strip()
+                        return {
+                            "platform": "npm",
+                            "name": name,
+                            "versions": [version],
+                            "latest": version
+                        }
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+        return None
+
+    @staticmethod
+    def check_git(name: str) -> Optional[List[Dict]]:
+        """检查 GitHub 是否存在相关仓库"""
+        try:
+            # 搜索 GitHub 仓库
+            result = subprocess.run(
+                ["curl", "-s", f"https://api.github.com/search/repositories?q={name}+kite"],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            if result.returncode == 0:
+                data = json.loads(result.stdout)
+                if data.get("total_count", 0) > 0:
+                    repos = []
+                    for item in data.get("items", [])[:5]:  # 最多返回 5 个
+                        repos.append({
+                            "platform": "git",
+                            "name": item["name"],
+                            "full_name": item["full_name"],
+                            "url": item["clone_url"],
+                            "description": item.get("description", "")
+                        })
+                    return repos
+        except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
+            pass
+        return None
+
+    @classmethod
+    def check_all(cls, name: str) -> Dict[str, any]:
+        """并行检查所有平台"""
+        results = {
+            "pypi": None,
+            "npm": None,
+            "git": None
+        }
+
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            futures = {
+                executor.submit(cls.check_pypi, name): "pypi",
+                executor.submit(cls.check_npm, name): "npm",
+                executor.submit(cls.check_git, name): "git"
+            }
+
+            for future in as_completed(futures):
+                platform = futures[future]
+                try:
+                    result = future.result()
+                    results[platform] = result
+                except Exception:
+                    pass
+
+        return results

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