@agentunion/kite 1.3.1 → 1.4.0

package/kite_cli/commands/rollback.py

@@ -0,0 +1,88 @@
+"""rollback 命令实现 - 回滚最后一次操作"""
+import shutil
+from pathlib import Path
+from kite_cli.utils.operation_log import get_last_operation, log_operation
+from kite_cli.utils.interactive import confirm_action
+from kite_cli.utils.paths import get_install_path
+from kite_cli.utils.i18n import t
+
+
+def run_rollback(args):
+    """执行回滚命令"""
+    skip_confirm = args.yes if hasattr(args, 'yes') else False
+
+    # 获取最后一次成功的操作
+    last_op = get_last_operation()
+
+    if not last_op:
+        print("[Error] 没有可回滚的操作")
+        return 1
+
+    if not last_op.get("success"):
+        print("[Error] 最后一次操作失败，无法回滚")
+        return 1
+
+    operation = last_op.get("operation")
+    details = last_op.get("details", {})
+
+    if operation == "install":
+        return rollback_install(details, skip_confirm)
+    elif operation == "uninstall":
+        print("[Error] 卸载操作无法自动回滚")
+        print("[Info] 请手动重新安装模块")
+        return 1
+    elif operation == "update":
+        print("[Error] 更新操作无法自动回滚")
+        print("[Info] 请手动安装旧版本")
+        return 1
+    else:
+        print(f"[Error] 不支持回滚操作类型: {operation}")
+        return 1
+
+
+def rollback_install(details: dict, skip_confirm: bool) -> int:
+    """回滚安装操作"""
+    module = details.get("module", "unknown")
+    location = details.get("location", "")
+    path = details.get("path", "")
+
+    if not path:
+        print("[Error] 无法确定模块路径")
+        return 1
+
+    module_path = Path(path)
+
+    if not module_path.exists():
+        print(f"[Warning] 模块已不存在: {module_path}")
+        return 0
+
+    # 确认回滚
+    if not skip_confirm:
+        if not confirm_action(f"确认回滚安装 {module} (删除 {location})？"):
+            print("[Cancelled] 已取消")
+            return 1
+
+    # 删除模块
+    try:
+        shutil.rmtree(module_path)
+        print(f"[Done] 已回滚安装: {module} from {location}")
+
+        # 记录回滚操作
+        log_operation("rollback", {
+            "original_operation": "install",
+            "module": module,
+            "location": location,
+            "path": str(module_path)
+        }, success=True)
+
+        return 0
+
+    except Exception as e:
+        print(f"[Error] 回滚失败: {e}")
+
+        log_operation("rollback", {
+            "original_operation": "install",
+            "module": module
+        }, success=False, error=str(e))
+
+        return 1

package/kite_cli/commands/search.py

@@ -0,0 +1,73 @@
+"""search 命令实现"""
+from kite_cli.core.checker import PlatformChecker
+from kite_cli.utils.i18n import t
+
+
+def run_search(args):
+    """执行搜索命令"""
+    keyword = args.keyword
+    from_platform = args.from_platform
+
+    print(t('searching_for', keyword=keyword) + "\n")
+
+    if from_platform:
+        # 指定平台搜索
+        results = search_single_platform(keyword, from_platform)
+    else:
+        # 搜索所有平台
+        results = PlatformChecker.check_all(keyword)
+
+    # 显示结果
+    found_count = 0
+
+    # PyPI
+    if results.get("pypi"):
+        found_count += 1
+        pypi = results["pypi"]
+        print(f"【{t('search_pypi')}】")
+        print(f"  • {pypi['name']}")
+        print(f"    {t('search_latest_version')}: {pypi['latest']}")
+        if len(pypi['versions']) > 1:
+            print(f"    {t('search_available_versions')}: {', '.join(pypi['versions'][:5])}")
+        print()
+
+    # npm
+    if results.get("npm"):
+        found_count += 1
+        npm = results["npm"]
+        print(f"【{t('search_npm')}】")
+        print(f"  • {npm['name']}")
+        print(f"    {t('search_version')}: {npm['latest']}")
+        print()
+
+    # Git
+    if results.get("git"):
+        found_count += len(results["git"])
+        print(f"【{t('search_git')}】")
+        for repo in results["git"]:
+            print(f"  • {repo['full_name']}")
+            if repo.get("description"):
+                print(f"    {repo['description']}")
+            print(f"    {repo['url']}")
+            print()
+
+    if found_count == 0:
+        print(t('no_results'))
+        return 1
+    else:
+        print(t('found_results', count=found_count))
+        return 0
+
+
+def search_single_platform(keyword: str, platform: str):
+    """搜索单个平台"""
+    results = {"pypi": None, "npm": None, "git": None}
+
+    if platform == "pypi":
+        results["pypi"] = PlatformChecker.check_pypi(keyword)
+    elif platform == "npm":
+        results["npm"] = PlatformChecker.check_npm(keyword)
+    elif platform == "git":
+        results["git"] = PlatformChecker.check_git(keyword)
+
+    return results

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