@agentunion/kite 1.3.2 → 1.4.0

package/kite_cli/commands/uninstall.py

@@ -0,0 +1,85 @@
+"""uninstall 命令实现"""
+import shutil
+from pathlib import Path
+from kite_cli.utils.paths import get_install_path
+from kite_cli.utils.interactive import confirm_action
+from kite_cli.utils.i18n import t
+from kite_cli.utils.operation_log import log_operation
+
+
+def run_uninstall(args):
+    """执行卸载命令"""
+    module_name = args.name
+    location = args.location
+    uninstall_all = args.all
+    skip_confirm = args.yes
+
+    print(t('uninstalling', name=module_name))
+
+    # 查找模块
+    if uninstall_all:
+        # 卸载所有位置
+        locations = ["dev", "local", "global"]
+    elif location:
+        # 指定位置
+        locations = [location]
+    else:
+        # 自动查找
+        locations = find_module_locations(module_name)
+        if not locations:
+            print(t('module_not_found', name=module_name))
+            return 1
+
+    # 确认卸载
+    if not skip_confirm:
+        location_names = ", ".join(locations)
+        if not confirm_action(f"{t('uninstalling', name=module_name)} ({location_names})？"):
+            print(t('update_cancelled'))
+            return 1
+
+    # 执行卸载
+    success_count = 0
+    uninstalled_paths = []
+    for loc in locations:
+        module_path = get_install_path(loc, module_name)
+        if module_path.exists():
+            try:
+                shutil.rmtree(module_path)
+                print(t('uninstalled', location=loc, path=module_path))
+                success_count += 1
+                uninstalled_paths.append({"location": loc, "path": str(module_path)})
+            except Exception as e:
+                print(f"[Error] {t('update_failed', error=str(e))} ({loc})")
+        else:
+            print(f"[Warning] {t('module_not_found', name='')} ({loc}): {module_path}")
+
+    if success_count > 0:
+        # 记录操作日志
+        log_operation("uninstall", {
+            "module": module_name,
+            "locations": uninstalled_paths
+        }, success=True)
+
+        print(t('uninstall_complete', count=success_count))
+        print(t('restart_hint'))
+        return 0
+    else:
+        log_operation("uninstall", {
+            "module": module_name
+        }, success=False, error="No modules found")
+
+        print(t('uninstall_none'))
+        return 1
+
+
+def find_module_locations(module_name: str):
+    """查找模块在哪些位置存在"""
+    locations = []
+    for loc in ["dev", "local", "global"]:
+        try:
+            module_path = get_install_path(loc, module_name)
+            if module_path.exists():
+                locations.append(loc)
+        except Exception:
+            pass
+    return locations

package/kite_cli/commands/update.py

@@ -0,0 +1,118 @@
+"""update 命令实现"""
+import sys
+import subprocess
+from pathlib import Path
+from kite_cli.utils.paths import get_install_path
+from kite_cli.core.install_info import read_install_info
+from kite_cli.utils.interactive import confirm_action
+from kite_cli.utils.i18n import t
+
+
+def run_update(args):
+    """执行更新命令"""
+    module_name = args.name if hasattr(args, 'name') else None
+    location = args.location if hasattr(args, 'location') else None
+    to_version = args.to_version if hasattr(args, 'to_version') else None
+    update_all = args.all if hasattr(args, 'all') else False
+    skip_confirm = args.yes if hasattr(args, 'yes') else False
+
+    if update_all:
+        print(t('update_not_implemented'))
+        return 1
+
+    if not module_name:
+        print(t('update_specify_name'))
+        return 1
+
+    # 显示更新信息
+    if to_version:
+        print(t('updating_module', name=f"{module_name} → {to_version}"))
+    else:
+        print(t('updating_module', name=module_name))
+
+    # 查找模块
+    if location:
+        locations = [location]
+    else:
+        locations = find_module_locations(module_name)
+        if not locations:
+            print(t('update_not_found', name=module_name))
+            return 1
+
+    # 只更新第一个找到的位置
+    loc = locations[0]
+    module_path = get_install_path(loc, module_name)
+
+    # 读取安装信息
+    install_info = read_install_info(module_path)
+    if not install_info:
+        print(t('update_no_install_info'))
+        print(t('update_manual_reinstall', name=module_name, location=loc))
+        return 1
+
+    source = install_info.get("source", {})
+    source_type = source.get("type")
+
+    if not source_type:
+        print(t('update_incomplete_info'))
+        return 1
+
+    # 构建安装命令
+    if source_type == "pypi":
+        source_arg = source.get("package", module_name)
+        # 如果指定了版本，添加版本号
+        if to_version:
+            source_arg = f"{source_arg}@{to_version}"
+        from_arg = "-f pypi"
+    elif source_type == "npm":
+        source_arg = source.get("package", module_name)
+        # 如果指定了版本，添加版本号
+        if to_version:
+            source_arg = f"{source_arg}@{to_version}"
+        from_arg = "-f npm"
+    elif source_type == "git":
+        source_arg = source.get("url", "")
+        from_arg = "-f git"
+        # Git 源不支持版本号
+        if to_version:
+            print("[Warning] Git 源不支持 --to 参数，将更新到最新提交")
+    elif source_type == "local":
+        print(t('update_local_no_auto'))
+        return 1
+    else:
+        print(t('update_unknown_source', type=source_type))
+        return 1
+
+    if not skip_confirm:
+        confirm_msg = t('update_confirm', name=module_name, source=source_type)
+        if to_version:
+            confirm_msg = f"确认更新 {module_name} 到版本 {to_version}？"
+        if not confirm_action(confirm_msg):
+            print(t('update_cancelled'))
+            return 1
+
+    # 调用 install 命令
+    print(t('reinstalling', name=module_name))
+    try:
+        cmd = [
+            sys.executable, "-m", "kite_cli", "install",
+            source_arg, "-l", loc, from_arg, "-y"
+        ]
+        result = subprocess.run(cmd, capture_output=False, text=True)
+        return result.returncode
+    except Exception as e:
+        print(t('update_failed', error=str(e)))
+        return 1
+
+
+def find_module_locations(module_name: str):
+    """查找模块在哪些位置存在"""
+    locations = []
+    for loc in ["dev", "local", "global"]:
+        try:
+            module_path = get_install_path(loc, module_name)
+            if module_path.exists():
+                locations.append(loc)
+        except Exception:
+            pass
+    return locations

package/kite_cli/core/__init__.py

@@ -0,0 +1 @@
+"""核心功能模块"""

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