@agentunion/kite 1.3.2 → 1.5.0

package/kite_cli/commands/list.py

@@ -0,0 +1,143 @@
+"""list 命令实现 - 列出启动器能找到的所有模块"""
+import os
+import sys
+from pathlib import Path
+from kite_cli.utils.i18n import t
+
+
+def run_list(args):
+    """执行列表命令 - 使用启动器的模块扫描器"""
+    verbose = args.verbose
+
+    # 确保环境变量设置
+    if "KITE_PROJECT" not in os.environ:
+        # 尝试从当前目录推断
+        cwd = Path.cwd()
+        if (cwd / "launcher").exists() and (cwd / "kernel").exists():
+            os.environ["KITE_PROJECT"] = str(cwd)
+        else:
+            print("[Error] 错误: 未找到 KITE_PROJECT 环境变量")
+            print("[Info] 请在 Kite 项目目录下运行此命令")
+            return 1
+
+    # 导入启动器的模块扫描器
+    project_root = Path(os.environ["KITE_PROJECT"])
+    launcher_path = project_root / "launcher"
+
+    if not launcher_path.exists():
+        print(f"[Error] 错误: 未找到 launcher 目录: {launcher_path}")
+        return 1
+
+    # 添加到 sys.path
+    if str(launcher_path.parent) not in sys.path:
+        sys.path.insert(0, str(launcher_path.parent))
+
+    try:
+        from launcher.module_scanner import ModuleScanner
+    except ImportError as e:
+        print(f"[Error] 错误: 无法导入 ModuleScanner: {e}")
+        return 1
+
+    # 读取 discovery 配置（如果存在）
+    discovery = {}
+    discovery_file = launcher_path / "discovery.yaml"
+    if discovery_file.exists():
+        try:
+            import yaml
+            with open(discovery_file, "r", encoding="utf-8") as f:
+                discovery = yaml.safe_load(f) or {}
+        except Exception as e:
+            print(f"[Warning] 警告: 无法读取 discovery.yaml: {e}")
+
+    # 扫描模块
+    scanner = ModuleScanner(discovery=discovery, launcher_dir=str(launcher_path))
+    modules = scanner.scan()
+
+    # 手动添加 kernel 模块（ModuleScanner 不扫描 kernel 目录本身）
+    kernel_dir_path = project_root / "kernel"
+    kernel_module_md = kernel_dir_path / "module.md"
+    if kernel_module_md.exists():
+        try:
+            kernel_info = scanner._try_load(str(kernel_dir_path))
+            if kernel_info and kernel_info.name not in modules:
+                modules[kernel_info.name] = kernel_info
+        except Exception as e:
+            print(f"[Warning] 警告: 无法加载 kernel 模块: {e}")
+
+    if not modules:
+        print(t('no_modules'))
+        return 0
+
+    # 分类模块
+    kernel_modules = []
+    builtin_modules = []
+    external_modules = []
+
+    extensions_dir = project_root / "extensions"
+    kernel_dir = project_root / "kernel"
+
+    for name, info in modules.items():
+        module_path = Path(info.module_dir)
+
+        # 判断模块类型
+        # 1. kernel 目录下的模块 = 内核模块
+        if module_path.parent == kernel_dir or name == "kernel":
+            kernel_modules.append((name, info))
+        # 2. extensions 目录下的模块 = 内置模块
+        elif module_path.is_relative_to(extensions_dir):
+            builtin_modules.append((name, info))
+        # 3. 其他位置的模块 = 外置模块
+        else:
+            external_modules.append((name, info))
+
+    # 显示结果
+    print(t('installed_modules') + "\n")
+
+    if kernel_modules:
+        print(f"【{t('category_kernel')}】")
+        for name, info in sorted(kernel_modules, key=lambda x: x[0]):
+            _print_module(name, info, verbose)
+        print()
+
+    if builtin_modules:
+        print(f"【{t('category_builtin')}】")
+        for name, info in sorted(builtin_modules, key=lambda x: x[0]):
+            _print_module(name, info, verbose)
+        print()
+
+    if external_modules:
+        print(f"【{t('category_external')}】")
+        for name, info in sorted(external_modules, key=lambda x: x[0]):
+            _print_module(name, info, verbose)
+        print()
+
+    total = len(modules)
+    print(t('total_modules', count=total))
+    print(t('stats_breakdown', kernel=len(kernel_modules), builtin=len(builtin_modules), external=len(external_modules)))
+
+    return 0
+
+
+def _print_module(name, info, verbose):
+    """打印单个模块信息"""
+    display_name = info.display_name or name
+    version = info.version or "unknown"
+    state_icon = "✓" if info.state == "enabled" else "○"
+
+    if verbose:
+        print(f"  {state_icon} {display_name} (v{version})")
+        print(f"    名称: {name}")
+        print(f"    类型: {info.type}")
+        print(f"    状态: {info.state}")
+        print(f"    运行时: {info.runtime}")
+        print(f"    入口: {info.entry}")
+        print(f"    路径: {info.module_dir}")
+        if info.depends_on:
+            print(f"    依赖: {', '.join(info.depends_on)}")
+        print()
+    else:
+        # 类型标签国际化
+        type_key = f"type_{info.type}"
+        type_label = t(type_key) if type_key in ['type_kernel', 'type_infrastructure', 'type_channel', 'type_agent', 'type_service', 'type_tool'] else info.type
+        type_badge = f"[{type_label}]"
+        print(f"  {state_icon} {display_name} (v{version}) {type_badge}")

package/kite_cli/commands/log.py

@@ -0,0 +1,81 @@
+"""log 命令实现 - 查看操作日志"""
+from datetime import datetime
+from kite_cli.utils.operation_log import read_operations, get_log_file
+from kite_cli.utils.i18n import t
+
+
+def run_log(args):
+    """执行日志查看命令"""
+    limit = args.limit if hasattr(args, 'limit') else 20
+    show_path = args.path if hasattr(args, 'path') else False
+
+    if show_path:
+        # 显示日志文件路径
+        log_file = get_log_file()
+        print(f"[Info] 日志文件路径: {log_file}")
+        return 0
+
+    # 读取操作日志
+    operations = read_operations(limit=limit)
+
+    if not operations:
+        print("[Info] 暂无操作记录")
+        return 0
+
+    print(f"[Log] 最近 {len(operations)} 条操作记录:\n")
+
+    for op in operations:
+        timestamp = op.get("timestamp", "unknown")
+        operation = op.get("operation", "unknown")
+        success = op.get("success", True)
+        details = op.get("details", {})
+        error = op.get("error")
+
+        # 格式化时间戳
+        try:
+            dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+            time_str = dt.strftime("%Y-%m-%d %H:%M:%S")
+        except Exception:
+            time_str = timestamp
+
+        # 状态标记
+        status = "[Done]" if success else "[Error]"
+
+        # 操作类型
+        if operation == "install":
+            module = details.get("module", "unknown")
+            version = details.get("version", "")
+            location = details.get("location", "")
+            print(f"{time_str} {status} install {module} v{version} -> {location}")
+            if error:
+                print(f"           错误: {error}")
+
+        elif operation == "uninstall":
+            module = details.get("module", "unknown")
+            locations = details.get("locations", [])
+            if locations:
+                loc_str = ", ".join([l["location"] for l in locations])
+                print(f"{time_str} {status} uninstall {module} from {loc_str}")
+            else:
+                print(f"{time_str} {status} uninstall {module}")
+            if error:
+                print(f"           错误: {error}")
+
+        elif operation == "update":
+            module = details.get("module", "unknown")
+            print(f"{time_str} {status} update {module}")
+            if error:
+                print(f"           错误: {error}")
+
+        elif operation == "clean":
+            cleaned = details.get("cleaned", [])
+            print(f"{time_str} {status} clean ({len(cleaned)} items)")
+
+        else:
+            print(f"{time_str} {status} {operation}")
+            if error:
+                print(f"           错误: {error}")
+
+        print()
+
+    return 0

package/kite_cli/commands/prepare.py

@@ -0,0 +1,49 @@
+"""
+kite prepare 命令
+
+打包前的准备工作：
+1. 扫描所有模块的依赖
+2. 生成 dependencies_lock.json
+3. 更新 python_version.json
+"""
+
+import sys
+from pathlib import Path
+
+
+def run_prepare(args):
+    """执行打包准备"""
+    # 导入扫描脚本
+    project_root = Path(__file__).parent.parent.parent
+
+    # 添加到 sys.path
+    sys.path.insert(0, str(project_root))
+
+    # 导入并执行扫描
+    from scripts.scan_dependencies import main as scan_main
+
+    print("=" * 60)
+    print("  Kite 打包准备")
+    print("=" * 60)
+    print()
+
+    try:
+        scan_main()
+        print()
+        print("✓ 打包准备完成")
+        print()
+        print("生成的文件:")
+        print(f"  - {project_root / 'dependencies_lock.json'}")
+        print(f"  - {project_root / 'python_version.json'}")
+        print()
+        print("下一步:")
+        print("  1. 检查生成的文件")
+        print("  2. 提交到 git: git add dependencies_lock.json python_version.json")
+        print("  3. 发布: npm publish")
+        return 0
+
+    except Exception as e:
+        print(f"\n✗ 打包准备失败: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1

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/commands/venv_setup.py

@@ -0,0 +1,56 @@
+"""
+kite venv-setup 命令
+
+只负责创建虚拟环境
+"""
+
+import sys
+from pathlib import Path
+
+
+def run_venv_setup(args):
+    """创建虚拟环境"""
+    project_root = Path(__file__).parent.parent.parent
+    sys.path.insert(0, str(project_root))
+
+    from core.env_checker import (
+        get_venv_path,
+        check_venv_exists,
+        create_venv,
+        check_python_version
+    )
+
+    print("=" * 60)
+    print("  Kite 虚拟环境准备")
+    print("=" * 60)
+    print()
+
+    try:
+        # 1. 检查 Python 版本
+        py_ok, py_version, required_version = check_python_version()
+        if not py_ok:
+            print(f"✗ Python 版本不匹配: {py_version}（需要 {required_version}）")
+            return 1
+
+        print(f"✓ Python 版本: {py_version}")
+
+        # 2. 检查虚拟环境
+        venv_ok, venv_msg = check_venv_exists()
+        if venv_ok:
+            print(f"✓ 虚拟环境已存在: {get_venv_path()}")
+            return 0
+
+        # 3. 创建虚拟环境
+        print(f"正在创建虚拟环境...")
+        if not create_venv():
+            print("✗ 虚拟环境创建失败")
+            return 1
+
+        print(f"✓ 虚拟环境创建成功: {get_venv_path()}")
+        return 0
+
+    except Exception as e:
+        print(f"\n✗ 虚拟环境准备失败: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1

package/kite_cli/core/__init__.py

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