@agentunion/kite 1.3.2 → 1.4.0

package/kite_cli/commands/install.py

@@ -0,0 +1,313 @@
+"""install 命令实现"""
+import os
+import tempfile
+import shutil
+from pathlib import Path
+from kite_cli.core.checker import PlatformChecker
+from kite_cli.core.downloader import Downloader
+from kite_cli.core.validator import Validator
+from kite_cli.core.dependency import DependencyInstaller
+from kite_cli.core.install_info import record_install_info
+from kite_cli.utils.interactive import select_source, select_location, confirm_action
+from kite_cli.utils.paths import get_install_path
+from kite_cli.utils.i18n import t
+from kite_cli.utils.operation_log import log_operation
+from kite_cli.utils.version import parse_version_spec, filter_versions, get_latest_version
+
+
+def run_install(args):
+    """执行安装命令"""
+    source = args.source
+    location = args.location
+    from_platform = args.from_platform
+    skip_confirm = args.yes
+    no_deps = args.no_deps
+
+    # 如果没有指定 source，检查当前目录
+    if not source:
+        cwd = Path.cwd()
+        module_md = cwd / "module.md"
+
+        if module_md.exists():
+            print(f"[Info] 检测到当前目录包含 module.md")
+            source = str(cwd)
+            from_platform = "local"
+            print(f"[Info] 将安装当前目录: {source}")
+        else:
+            print("[Error] 缺少参数 <source>")
+            print("[Info] 请指定模块名，或在包含 module.md 的目录下执行")
+            print("[Info] 示例:")
+            print("  kite install requests          # 安装 PyPI/npm 包")
+            print("  kite install ./my-module       # 安装本地模块")
+            print("  kite install                   # 在模块目录下安装当前目录")
+            return 1
+
+    # 解析版本号 (如 pkg@1.2.0)
+    package_name, version_spec = parse_version_spec(source)
+
+    # 保留名称检查 - 防止安装 Kite 框架本身或核心组件
+    RESERVED_NAMES = ['kite', 'launcher', 'kernel', 'core']
+
+    # 提取模块名（去除路径、URL等）
+    module_name = package_name.lower().strip()
+    if '/' in module_name:
+        module_name = module_name.split('/')[-1]
+    if module_name.endswith('.git'):
+        module_name = module_name[:-4]
+
+    # 只检查完全匹配的保留名称
+    if module_name in RESERVED_NAMES:
+        print(t('reserved_name_error', name=source))
+        print(t('reserved_name_hint', name=module_name))
+        print(t('update_framework_hint'))
+        return 1
+
+    if version_spec:
+        print(t('searching_module', name=f"{package_name}@{version_spec}"))
+    else:
+        print(t('searching_module', name=package_name))
+
+    # 步骤 1: 检查各平台
+    if from_platform:
+        # 指定了平台，只检查该平台
+        candidates = check_single_platform(package_name, from_platform, version_spec)
+    else:
+        # 未指定平台，检查所有平台
+        candidates = check_all_platforms(package_name, version_spec)
+
+    if not candidates:
+        print(t('module_not_found', name=source))
+        return 1
+
+    # 步骤 2: 用户选择来源（如果有多个）
+    if len(candidates) > 1:
+        selected = select_source(candidates)
+        if not selected:
+            print("[Cancelled] 已取消")
+            return 1
+    else:
+        selected = candidates[0]
+
+    print(t('select_source', platform=selected['platform'], name=selected.get('name', source)))
+
+    # 步骤 3: 下载到临时目录
+    temp_dir = Path(tempfile.mkdtemp(prefix="kite-install-"))
+    try:
+        print(t('downloading'))
+        downloaded_dir, error = download_module(selected, temp_dir)
+        if not downloaded_dir:
+            print(t('download_failed'))
+            if error:
+                print(f"  {error}")
+            return 1
+
+        print(t('download_complete', path=downloaded_dir))
+
+        # 步骤 4: 验证 module.md
+        print(t('validating'))
+
+        # 对于本地安装，不验证模块名，直接读取 module.md
+        if selected["platform"] == "local":
+            module_md = Validator.find_module_md(downloaded_dir)
+            if not module_md:
+                print(t('validation_failed', error="未找到 module.md"))
+                return 1
+            module_data = Validator.parse_module_md(module_md)
+            if not module_data or not module_data.get("name"):
+                print(t('validation_failed', error="无法解析 module.md 或缺少 name 字段"))
+                return 1
+        else:
+            # 其他平台需要验证模块名匹配
+            valid, error, module_data = Validator.validate_module(downloaded_dir, source)
+            if not valid:
+                print(t('validation_failed', error=error))
+                return 1
+
+        print(t('validation_passed', name=module_data.get('name'), version=module_data.get('version', 'unknown')))
+
+        # 步骤 5: 选择安装位置
+        if not location:
+            location = select_location()
+            if not location:
+                print("[Cancelled] 已取消")
+                return 1
+
+        # 步骤 6: 检查冲突
+        install_path = get_install_path(location, module_data['name'])
+        if install_path.exists():
+            if not skip_confirm:
+                if not confirm_action(f"模块 {module_data['name']} 已存在，是否覆盖？"):
+                    print("[Cancelled] 已取消")
+                    return 1
+            print("[Warning] 删除旧版本...")
+            shutil.rmtree(install_path)
+
+        # 步骤 7: 安装依赖
+        if not no_deps:
+            print(t('installing_deps'))
+            if not DependencyInstaller.install_all_deps(downloaded_dir, module_data, location, no_deps):
+                print(t('deps_failed'))
+                if not skip_confirm:
+                    if not confirm_action("是否继续安装模块（不含依赖）？"):
+                        return 1
+                else:
+                    return 1
+
+        # 步骤 8: 复制到目标位置
+        print(t('installing_to', path=install_path))
+        install_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(downloaded_dir, install_path)
+
+        # 步骤 9: 记录安装信息
+        source_info = {
+            "type": selected["platform"],
+            "name": selected.get("name", source),
+        }
+        if selected["platform"] == "pypi":
+            source_info["package"] = selected["name"]
+            source_info["version"] = selected.get("latest")
+        elif selected["platform"] == "npm":
+            source_info["package"] = selected["name"]
+            source_info["version"] = selected.get("latest")
+        elif selected["platform"] == "git":
+            source_info["url"] = selected["url"]
+            source_info["full_name"] = selected.get("full_name")
+        elif selected["platform"] == "local":
+            source_info["path"] = selected["path"]
+
+        record_install_info(install_path, source_info, module_data, location)
+
+        # 记录操作日志
+        log_operation("install", {
+            "module": module_data['name'],
+            "version": module_data.get('version', 'unknown'),
+            "source": source_info,
+            "location": location,
+            "path": str(install_path)
+        }, success=True)
+
+        print(t('install_complete'))
+        print(t('restart_hint'))
+
+        return 0
+
+    except Exception as e:
+        # 记录失败日志
+        log_operation("install", {
+            "source": source,
+            "location": location
+        }, success=False, error=str(e))
+        raise
+
+    finally:
+        # 清理临时目录
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def check_single_platform(source: str, platform: str, version_spec: str = None):
+    """检查单个平台"""
+    candidates = []
+
+    if platform == "pypi":
+        result = PlatformChecker.check_pypi(source)
+        if result:
+            # 根据版本规范过滤
+            if version_spec:
+                matched_versions = filter_versions(result.get("versions", []), version_spec)
+                if matched_versions:
+                    result["matched_version"] = matched_versions[0]  # 选择最新的匹配版本
+                    result["version_spec"] = version_spec
+                    candidates.append(result)
+            else:
+                candidates.append(result)
+
+    elif platform == "npm":
+        result = PlatformChecker.check_npm(source)
+        if result:
+            # 根据版本规范过滤
+            if version_spec:
+                matched_versions = filter_versions(result.get("versions", []), version_spec)
+                if matched_versions:
+                    result["matched_version"] = matched_versions[0]
+                    result["version_spec"] = version_spec
+                    candidates.append(result)
+            else:
+                candidates.append(result)
+
+    elif platform == "git":
+        results = PlatformChecker.check_git(source)
+        if results:
+            candidates.extend(results)
+
+    elif platform == "local":
+        # 本地路径直接返回
+        if Path(source).exists():
+            candidates.append({
+                "platform": "local",
+                "path": source
+            })
+
+    return candidates
+
+
+def check_all_platforms(source: str, version_spec: str = None):
+    """检查所有平台"""
+    candidates = []
+
+    # 先检查是否是本地路径
+    if Path(source).exists():
+        candidates.append({
+            "platform": "local",
+            "path": source,
+            "name": Path(source).name
+        })
+        return candidates
+
+    # 并行检查 PyPI/npm/Git
+    results = PlatformChecker.check_all(source)
+
+    if results["pypi"]:
+        result = results["pypi"]
+        # 根据版本规范过滤
+        if version_spec:
+            matched_versions = filter_versions(result.get("versions", []), version_spec)
+            if matched_versions:
+                result["matched_version"] = matched_versions[0]
+                result["version_spec"] = version_spec
+                candidates.append(result)
+        else:
+            candidates.append(result)
+
+    if results["npm"]:
+        result = results["npm"]
+        # 根据版本规范过滤
+        if version_spec:
+            matched_versions = filter_versions(result.get("versions", []), version_spec)
+            if matched_versions:
+                result["matched_version"] = matched_versions[0]
+                result["version_spec"] = version_spec
+                candidates.append(result)
+        else:
+            candidates.append(result)
+
+    if results["git"]:
+        candidates.extend(results["git"])
+
+    return candidates
+
+
+def download_module(selected: dict, temp_dir: Path):
+    """根据选择的来源下载模块"""
+    platform = selected["platform"]
+    version = selected.get("matched_version") or selected.get("latest")
+
+    if platform == "pypi":
+        return Downloader.download_pypi(selected["name"], temp_dir, version)
+    elif platform == "npm":
+        return Downloader.download_npm(selected["name"], temp_dir, version)
+    elif platform == "git":
+        return Downloader.download_git(selected["url"], temp_dir)
+    elif platform == "local":
+        return Downloader.download_local(selected["path"], temp_dir)
+
+    return None, "未知的平台类型"

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/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