@agentunion/kite 1.5.0 → 1.6.1

package/kite_cli/commands/outdated.py

@@ -0,0 +1,202 @@
+"""outdated 命令实现 - 列出可更新的模块"""
+import sys
+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.core.checker import PlatformChecker
+from kite_cli.utils.version import Version
+from kite_cli.utils.i18n import t
+from kite_cli.utils.colors import print_info, print_success, success, warning, dim, highlight
+
+
+def run_outdated(args):
+    """执行 outdated 命令"""
+    location = args.location if hasattr(args, 'location') else None
+
+    print_info("检查可更新的模块...")
+    print()
+
+    # 获取所有已安装模块
+    modules = get_installed_modules(location)
+
+    if not modules:
+        print("[Info] 没有找到已安装的模块")
+        return 0
+
+    # 检查每个模块的更新
+    outdated_modules = []
+
+    for module_info in modules:
+        module_name = module_info['name']
+        current_version = module_info['version']
+        location_name = module_info['location']
+        install_info = module_info['install_info']
+
+        if not install_info:
+            continue
+
+        source = install_info.get('source', {})
+        source_type = source.get('type')
+
+        # 只检查 PyPI 和 npm 源
+        if source_type not in ['pypi', 'npm']:
+            continue
+
+        # 查询最新版本
+        latest_version = get_latest_version(source_type, source.get('package', module_name))
+
+        if not latest_version:
+            continue
+
+        # 比较版本
+        try:
+            current_v = Version(current_version)
+            latest_v = Version(latest_version)
+
+            if latest_v > current_v:
+                outdated_modules.append({
+                    'name': module_name,
+                    'current': current_version,
+                    'latest': latest_version,
+                    'location': location_name,
+                    'source': source_type
+                })
+        except Exception:
+            # 版本号解析失败，跳过
+            continue
+
+    # 显示结果
+    if not outdated_modules:
+        print_success("✓ 所有模块都是最新版本")
+        return 0
+
+    print_info(f"发现 {highlight(str(len(outdated_modules)))} 个可更新的模块:")
+    print()
+
+    # 表格头
+    print(f"{'模块名':<25} {'当前版本':<15} {'最新版本':<15} {'位置':<10} {'来源':<8}")
+    print(dim("-" * 80))
+
+    # 表格内容
+    for mod in outdated_modules:
+        name_col = highlight(mod['name'])
+        current_col = warning(mod['current'])
+        latest_col = success(mod['latest'])
+        print(f"{name_col:<34} {current_col:<24} {latest_col:<24} {mod['location']:<10} {mod['source']:<8}")
+
+    print()
+    print_info("更新命令:")
+    print(f"  {dim('kite update <name> --to <version>')}  # 更新到指定版本")
+    print(f"  {dim('kite update --all')}                  # 更新所有模块")
+
+    return 0
+
+
+def get_installed_modules(location_filter=None):
+    """获取所有已安装的模块"""
+    modules = []
+
+    # 确定要扫描的位置
+    if location_filter:
+        locations = [location_filter]
+    else:
+        locations = ['dev', 'local', 'global']
+
+    for location in locations:
+        try:
+            # 获取安装路径
+            if location == 'dev':
+                import os
+                if 'KITE_PROJECT' not in os.environ:
+                    continue
+                base_path = Path(os.environ['KITE_PROJECT']) / 'extensions'
+            elif location == 'local':
+                import os
+                if 'KITE_INSTANCE_DIR' in os.environ:
+                    base_path = Path(os.environ['KITE_INSTANCE_DIR']) / 'extensions'
+                else:
+                    base_path = Path.home() / '.kite' / 'workspace' / 'default' / 'extensions'
+            else:  # global
+                base_path = Path.home() / '.kite' / 'modules'
+
+            if not base_path.exists():
+                continue
+
+            # 扫描模块目录
+            for module_dir in base_path.iterdir():
+                if not module_dir.is_dir():
+                    continue
+
+                module_md = module_dir / 'module.md'
+                if not module_md.exists():
+                    continue
+
+                # 读取 module.md 获取版本号
+                version = read_module_version(module_md)
+                if not version:
+                    continue
+
+                # 读取安装信息
+                install_info = read_install_info(module_dir)
+
+                modules.append({
+                    'name': module_dir.name,
+                    'version': version,
+                    'location': location,
+                    'path': module_dir,
+                    'install_info': install_info
+                })
+
+        except Exception as e:
+            # 跳过错误的位置
+            continue
+
+    return modules
+
+
+def read_module_version(module_md_path):
+    """从 module.md 读取版本号"""
+    try:
+        with open(module_md_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        # 简单解析 YAML frontmatter
+        if content.startswith('---'):
+            parts = content.split('---', 2)
+            if len(parts) >= 2:
+                frontmatter = parts[1]
+                for line in frontmatter.split('\n'):
+                    if line.strip().startswith('version:'):
+                        version = line.split(':', 1)[1].strip()
+                        # 移除引号
+                        version = version.strip('"').strip("'")
+                        return version
+
+        return None
+
+    except Exception:
+        return None
+
+
+def get_latest_version(source_type, package_name):
+    """获取包的最新版本"""
+    try:
+        if source_type == 'pypi':
+            result = PlatformChecker.check_pypi(package_name)
+            if result and 'versions' in result:
+                versions = result['versions']
+                if versions:
+                    # 返回最新版本（versions 已按降序排列）
+                    return versions[0]
+
+        elif source_type == 'npm':
+            result = PlatformChecker.check_npm(package_name)
+            if result and 'versions' in result:
+                versions = result['versions']
+                if versions:
+                    return versions[0]
+
+        return None
+
+    except Exception:
+        return None

package/kite_cli/commands/search.py

@@ -1,6 +1,8 @@
 """search 命令实现"""
 from kite_cli.core.checker import PlatformChecker
 from kite_cli.utils.i18n import t
+from kite_cli.utils.colors import success, info, dim, highlight, bold
+from kite_cli.utils.table import format_table
 
 
 def run_search(args):
@@ -8,7 +10,7 @@ def run_search(args):
     keyword = args.keyword
     from_platform = args.from_platform
 
-    print(t('searching_for', keyword=keyword) + "\n")
+    print(bold(t('searching_for', keyword=keyword)) + "\n")
 
     if from_platform:
         # 指定平台搜索
@@ -24,38 +26,52 @@ def run_search(args):
     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(bold(f"【{t('search_pypi')}】"))
+
+        headers = ['包名', '最新版本', '可用版本']
+        versions_str = ', '.join(pypi['versions'][:5]) if len(pypi['versions']) > 1 else '-'
+        rows = [[highlight(pypi['name']), success(pypi['latest']), dim(versions_str)]]
+
+        print(format_table(headers, rows))
         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(bold(f"【{t('search_npm')}】"))
+
+        headers = ['包名', '版本']
+        rows = [[highlight(npm['name']), success(npm['latest'])]]
+
+        print(format_table(headers, rows))
         print()
 
     # Git
     if results.get("git"):
         found_count += len(results["git"])
-        print(f"【{t('search_git')}】")
+        print(bold(f"【{t('search_git')}】"))
+
+        headers = ['仓库', '描述', 'URL']
+        rows = []
         for repo in results["git"]:
-            print(f"  • {repo['full_name']}")
-            if repo.get("description"):
-                print(f"    {repo['description']}")
-            print(f"    {repo['url']}")
-            print()
+            desc = repo.get("description", "-")
+            if desc and len(desc) > 50:
+                desc = desc[:47] + "..."
+            rows.append([
+                highlight(repo['full_name']),
+                dim(desc) if desc != "-" else "-",
+                info(repo['url'])
+            ])
+
+        print(format_table(headers, rows))
+        print()
 
     if found_count == 0:
-        print(t('no_results'))
+        print(dim(t('no_results')))
         return 1
     else:
-        print(t('found_results', count=found_count))
+        print(success(f"✓ {t('found_results', count=found_count)}"))
         return 0
 
 

package/kite_cli/commands/update.py

@@ -6,6 +6,8 @@ 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
+from kite_cli.utils.progress import ProgressBar
+from kite_cli.utils.colors import print_info, print_success, print_error, success, warning
 
 
 def run_update(args):
@@ -17,8 +19,7 @@ def run_update(args):
     skip_confirm = args.yes if hasattr(args, 'yes') else False
 
     if update_all:
-        print(t('update_not_implemented'))
-        return 1
+        return update_all_modules(location, to_version, skip_confirm)
 
     if not module_name:
         print(t('update_specify_name'))
@@ -116,3 +117,115 @@ def find_module_locations(module_name: str):
         except Exception:
             pass
     return locations
+
+
+def update_all_modules(location_filter, to_version, skip_confirm):
+    """批量更新所有模块"""
+    print_info("扫描已安装的模块...")
+
+    # 获取所有已安装模块
+    modules = []
+    locations = [location_filter] if location_filter else ["dev", "local", "global"]
+
+    for loc in locations:
+        try:
+            if loc == "dev":
+                import os
+                if 'KITE_PROJECT' not in os.environ:
+                    continue
+                base_path = Path(os.environ['KITE_PROJECT']) / 'extensions'
+            elif loc == "local":
+                import os
+                if 'KITE_INSTANCE_DIR' in os.environ:
+                    base_path = Path(os.environ['KITE_INSTANCE_DIR']) / 'extensions'
+                else:
+                    base_path = Path.home() / '.kite' / 'workspace' / 'default' / 'extensions'
+            else:  # global
+                base_path = Path.home() / '.kite' / 'modules'
+
+            if not base_path.exists():
+                continue
+
+            for module_dir in base_path.iterdir():
+                if not module_dir.is_dir():
+                    continue
+
+                install_info = read_install_info(module_dir)
+                if not install_info:
+                    continue
+
+                source = install_info.get('source', {})
+                source_type = source.get('type')
+
+                # 只更新 PyPI 和 npm 源
+                if source_type in ['pypi', 'npm']:
+                    modules.append({
+                        'name': module_dir.name,
+                        'location': loc,
+                        'source': source
+                    })
+        except Exception:
+            continue
+
+    if not modules:
+        print_info("没有找到可更新的模块")
+        return 0
+
+    print_info(f"找到 {len(modules)} 个可更新的模块")
+    print()
+
+    if not skip_confirm:
+        for mod in modules:
+            print(f"  - {mod['name']} ({mod['location']}) [{mod['source']['type']}]")
+        print()
+        if not confirm_action(f"确认更新这 {len(modules)} 个模块？"):
+            print_error("已取消")
+            return 1
+
+    # 批量更新（使用进度条）
+    success_count = 0
+    failed_count = 0
+
+    with ProgressBar(total=len(modules), desc="批量更新", unit="模块") as progress:
+        for i, mod in enumerate(modules, 1):
+            progress.set_description(f"更新 {mod['name']}")
+
+            source_type = mod['source']['type']
+            source_arg = mod['source'].get('package', mod['name'])
+
+            if to_version:
+                source_arg = f"{source_arg}@{to_version}"
+
+            from_arg = f"-f {source_type}"
+
+            try:
+                cmd = [
+                    sys.executable, "-m", "kite_cli.main",
+                    "install", source_arg,
+                    from_arg,
+                    "-l", mod['location'],
+                    "-y"
+                ]
+
+                result = subprocess.run(cmd, capture_output=True, text=True)
+
+                if result.returncode == 0:
+                    success_count += 1
+                else:
+                    failed_count += 1
+
+            except Exception:
+                failed_count += 1
+
+            progress.update(1)
+
+    print()
+    print_success(f"更新完成: {success_count} 成功")
+    if failed_count > 0:
+        print_error(f"{failed_count} 失败")
+
+    return 0 if failed_count == 0 else 1
+
+
+    return 0 if failed_count == 0 else 1
+

package/kite_cli/commands/venv_setup.py

@@ -29,28 +29,28 @@ def run_venv_setup(args):
         # 1. 检查 Python 版本
         py_ok, py_version, required_version = check_python_version()
         if not py_ok:
-            print(f"✗ Python 版本不匹配: {py_version}（需要 {required_version}）")
+            print(f"[X] Python 版本不匹配: {py_version}（需要 {required_version}）")
             return 1
 
-        print(f"✓ Python 版本: {py_version}")
+        print(f"[OK] Python 版本: {py_version}")
 
         # 2. 检查虚拟环境
         venv_ok, venv_msg = check_venv_exists()
         if venv_ok:
-            print(f"✓ 虚拟环境已存在: {get_venv_path()}")
+            print(f"[OK] 虚拟环境已存在: {get_venv_path()}")
             return 0
 
         # 3. 创建虚拟环境
         print(f"正在创建虚拟环境...")
         if not create_venv():
-            print("✗ 虚拟环境创建失败")
+            print("[X] 虚拟环境创建失败")
             return 1
 
-        print(f"✓ 虚拟环境创建成功: {get_venv_path()}")
+        print(f"[OK] 虚拟环境创建成功: {get_venv_path()}")
         return 0
 
     except Exception as e:
-        print(f"\n✗ 虚拟环境准备失败: {e}")
+        print(f"\n[X] 虚拟环境准备失败: {e}")
         import traceback
         traceback.print_exc()
         return 1

package/kite_cli/commands/why.py

@@ -0,0 +1,48 @@
+"""why 命令实现 - 显示为什么安装了某个模块"""
+from kite_cli.utils.dependency_graph import build_dependency_graph
+from kite_cli.utils.colors import print_info, print_error, highlight, dim, success
+
+
+def run_why(args):
+    """执行 why 命令"""
+    module_name = args.name
+    location = args.location if hasattr(args, 'location') else None
+
+    print_info(f"分析模块依赖关系: {module_name}")
+    print()
+
+    # 构建依赖图
+    locations = [location] if location else None
+    graph = build_dependency_graph(locations)
+
+    # 检查模块是否存在
+    if module_name not in graph.nodes:
+        print_error(f"模块 {module_name} 未安装")
+        return 1
+
+    # 获取反向依赖
+    rdeps = graph.get_reverse_dependencies(module_name)
+
+    if not rdeps:
+        print(success(f"✓ {module_name} 是顶层模块（没有其他模块依赖它）"))
+        return 0
+
+    # 显示反向依赖
+    print(highlight(f"{module_name} 被以下模块依赖:"))
+    print()
+
+    for dep in rdeps:
+        if dep in graph.nodes:
+            version = graph.nodes[dep]['version']
+            location_name = graph.nodes[dep]['location']
+            print(f"  • {highlight(dep)} (v{version}) [{location_name}]")
+
+            # 显示依赖路径
+            path = graph.find_path(dep, module_name)
+            if path and len(path) > 2:
+                path_str = " → ".join(path)
+                print(f"    {dim('路径:')} {dim(path_str)}")
+        else:
+            print(f"  • {dim(dep)} {dim('(未安装)')}")
+
+    return 0

package/kite_cli/core/config_manager.py

@@ -0,0 +1,145 @@
+"""配置管理器"""
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+
+# 默认配置
+DEFAULT_CONFIG = {
+    "default_location": "global",
+    "pypi_mirror": "",
+    "npm_registry": "",
+    "auto_update_check": False,
+    "confirm_install": True,
+    "confirm_uninstall": True,
+    "confirm_update": True,
+}
+
+# 配置项验证规则
+CONFIG_SCHEMA = {
+    "default_location": {
+        "type": "string",
+        "choices": ["dev", "local", "global"],
+        "description": "默认安装位置"
+    },
+    "pypi_mirror": {
+        "type": "string",
+        "description": "PyPI 镜像源 URL"
+    },
+    "npm_registry": {
+        "type": "string",
+        "description": "npm 镜像源 URL"
+    },
+    "auto_update_check": {
+        "type": "boolean",
+        "description": "自动检查更新"
+    },
+    "confirm_install": {
+        "type": "boolean",
+        "description": "安装前确认"
+    },
+    "confirm_uninstall": {
+        "type": "boolean",
+        "description": "卸载前确认"
+    },
+    "confirm_update": {
+        "type": "boolean",
+        "description": "更新前确认"
+    },
+}
+
+
+class ConfigManager:
+    """配置管理器"""
+
+    def __init__(self):
+        self.config_dir = Path.home() / '.kite' / 'data'
+        self.config_file = self.config_dir / 'cli_config.json'
+        self._config = None
+
+    def _ensure_config_dir(self):
+        """确保配置目录存在"""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def _load_config(self) -> dict:
+        """加载配置"""
+        if self._config is not None:
+            return self._config
+
+        self._ensure_config_dir()
+
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, 'r', encoding='utf-8') as f:
+                    user_config = json.load(f)
+                # 合并默认配置和用户配置
+                self._config = {**DEFAULT_CONFIG, **user_config}
+            except Exception:
+                self._config = DEFAULT_CONFIG.copy()
+        else:
+            self._config = DEFAULT_CONFIG.copy()
+
+        return self._config
+
+    def _save_config(self):
+        """保存配置"""
+        self._ensure_config_dir()
+        with open(self.config_file, 'w', encoding='utf-8') as f:
+            json.dump(self._config, f, indent=2, ensure_ascii=False)
+
+    def get(self, key: str) -> Any:
+        """获取配置值"""
+        config = self._load_config()
+        return config.get(key)
+
+    def set(self, key: str, value: Any) -> bool:
+        """设置配置值"""
+        if key not in CONFIG_SCHEMA:
+            return False
+
+        # 验证值
+        schema = CONFIG_SCHEMA[key]
+        if schema["type"] == "boolean":
+            if not isinstance(value, bool):
+                # 尝试转换
+                if isinstance(value, str):
+                    value = value.lower() in ['true', '1', 'yes', 'on']
+                else:
+                    return False
+        elif schema["type"] == "string":
+            value = str(value)
+            if "choices" in schema and value not in schema["choices"]:
+                return False
+
+        config = self._load_config()
+        config[key] = value
+        self._config = config
+        self._save_config()
+        return True
+
+    def unset(self, key: str) -> bool:
+        """删除配置项（恢复为默认值）"""
+        if key not in CONFIG_SCHEMA:
+            return False
+
+        config = self._load_config()
+        if key in config:
+            config[key] = DEFAULT_CONFIG[key]
+            self._config = config
+            self._save_config()
+        return True
+
+    def list_all(self) -> dict:
+        """列出所有配置"""
+        return self._load_config()
+
+    def reset(self):
+        """重置为默认配置"""
+        self._config = DEFAULT_CONFIG.copy()
+        self._save_config()
+
+    def get_schema(self, key: Optional[str] = None):
+        """获取配置项的 schema"""
+        if key:
+            return CONFIG_SCHEMA.get(key)
+        return CONFIG_SCHEMA