@agentunion/kite 1.5.0 → 1.6.1

package/kite_cli/commands/config.py

@@ -0,0 +1,156 @@
+"""config 命令实现 - 配置管理"""
+from kite_cli.core.config_manager import ConfigManager, CONFIG_SCHEMA, DEFAULT_CONFIG
+from kite_cli.utils.colors import print_success, print_error, success, warning, dim, highlight, bold
+
+
+def run_config(args):
+    """执行 config 命令"""
+    subcmd = args.subcmd if hasattr(args, 'subcmd') else None
+
+    if not subcmd:
+        print("[Error] 请指定子命令: list, get, set, unset, reset")
+        print("运行 'kite config --help' 查看用法")
+        return 1
+
+    mgr = ConfigManager()
+
+    if subcmd == "list":
+        return _cmd_list(mgr)
+    elif subcmd == "get":
+        return _cmd_get(mgr, args.key)
+    elif subcmd == "set":
+        return _cmd_set(mgr, args.key, args.value)
+    elif subcmd == "unset":
+        return _cmd_unset(mgr, args.key)
+    elif subcmd == "reset":
+        return _cmd_reset(mgr, args)
+    else:
+        print(f"[Error] 未知子命令: {subcmd}")
+        return 1
+
+
+def _cmd_list(mgr: ConfigManager):
+    """列出所有配置"""
+    config = mgr.list_all()
+    schema = mgr.get_schema()
+
+    print(bold("Kite CLI 配置项") + "\n")
+    print(f"  {'配置项':<22} {'当前值':<20} {'默认值':<20} 说明")
+    print("  " + dim("-" * 80))
+
+    for key, meta in schema.items():
+        current = config.get(key, '')
+        default = DEFAULT_CONFIG.get(key, '')
+
+        # 显示差异标记
+        changed = current != default
+        marker = warning("* ") if changed else "  "
+
+        # 布尔值转换显示
+        if meta["type"] == "boolean":
+            current_str = "true" if current else "false"
+            default_str = "true" if default else "false"
+        else:
+            current_str = str(current) if current else dim("(空)")
+            default_str = str(default) if default else dim("(空)")
+
+        # 高亮已修改的值
+        if changed:
+            current_str = highlight(current_str)
+
+        print(f"{marker}{key:<22} {current_str:<29} {default_str:<29} {dim(meta['description'])}")
+
+    print()
+    print(dim("* 号标记表示已修改的配置项"))
+    print(dim(f"配置文件: {mgr.config_file}"))
+    return 0
+
+
+def _cmd_get(mgr: ConfigManager, key: str):
+    """获取配置值"""
+    schema = mgr.get_schema(key)
+    if not schema:
+        print_error(f"未知配置项: {key}")
+        print(dim("运行 'kite config list' 查看所有配置项"))
+        return 1
+
+    value = mgr.get(key)
+
+    if schema["type"] == "boolean":
+        print("true" if value else "false")
+    else:
+        print(str(value) if value else "")
+    return 0
+
+
+def _cmd_set(mgr: ConfigManager, key: str, value: str):
+    """设置配置值"""
+    schema = mgr.get_schema(key)
+    if not schema:
+        print_error(f"未知配置项: {key}")
+        print(dim("运行 'kite config list' 查看所有配置项"))
+        return 1
+
+    # 检查可选值范围
+    if "choices" in schema:
+        if value not in schema["choices"]:
+            choices_str = ", ".join(schema["choices"])
+            print_error(f"'{key}' 的值必须是: {choices_str}")
+            return 1
+
+    # 布尔值校验
+    if schema["type"] == "boolean":
+        if value.lower() not in ["true", "false", "1", "0", "yes", "no", "on", "off"]:
+            print_error(f"'{key}' 的值必须是布尔值 (true/false)")
+            return 1
+
+    ok = mgr.set(key, value)
+    if ok:
+        # 显示实际存储值
+        actual = mgr.get(key)
+        if schema["type"] == "boolean":
+            actual_str = "true" if actual else "false"
+        else:
+            actual_str = str(actual)
+        print_success(f"{key} = {highlight(actual_str)}")
+        return 0
+    else:
+        print_error("设置失败")
+        return 1
+
+
+def _cmd_unset(mgr: ConfigManager, key: str):
+    """删除配置项（恢复默认）"""
+    schema = mgr.get_schema(key)
+    if not schema:
+        print_error(f"未知配置项: {key}")
+        return 1
+
+    ok = mgr.unset(key)
+    if ok:
+        default = DEFAULT_CONFIG.get(key, '')
+        if schema["type"] == "boolean":
+            default_str = "true" if default else "false"
+        else:
+            default_str = str(default) if default else "(空)"
+        print_success(f"{key} 已重置为默认值: {highlight(default_str)}")
+        return 0
+    else:
+        print_error("重置失败")
+        return 1
+
+
+def _cmd_reset(mgr: ConfigManager, args):
+    """重置所有配置为默认"""
+    skip_confirm = args.yes if hasattr(args, 'yes') else False
+
+    if not skip_confirm:
+        from kite_cli.utils.interactive import confirm_action
+        if not confirm_action("确认重置所有配置为默认值？"):
+            from kite_cli.utils.colors import print_cancelled
+            print_cancelled("已取消")
+            return 1
+
+    mgr.reset()
+    print_success("所有配置已重置为默认值")
+    return 0

package/kite_cli/commands/deps.py

@@ -0,0 +1,58 @@
+"""deps 命令实现 - 显示依赖树"""
+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_deps(args):
+    """执行 deps 命令"""
+    module_name = args.name
+    depth = args.depth if hasattr(args, 'depth') else -1
+    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
+
+    # 获取依赖树
+    deps = graph.get_dependencies(module_name, depth)
+
+    if not deps:
+        print(success(f"✓ {module_name} 没有依赖"))
+        return 0
+
+    # 显示依赖树
+    print(highlight(f"{module_name}"))
+    print_tree(deps, graph)
+
+    return 0
+
+
+def print_tree(deps, graph):
+    """打印依赖树"""
+    # 按深度分组
+    depth_map = {}
+    for dep, depth in deps:
+        if depth not in depth_map:
+            depth_map[depth] = []
+        depth_map[depth].append(dep)
+
+    # 打印
+    for depth in sorted(depth_map.keys()):
+        for dep in depth_map[depth]:
+            indent = "  " * depth
+            prefix = "└─" if depth > 0 else ""
+
+            # 检查是否已安装
+            if dep in graph.nodes:
+                version = graph.nodes[dep]['version']
+                print(f"{indent}{prefix} {highlight(dep)} (v{version})")
+            else:
+                print(f"{indent}{prefix} {dim(dep)} {dim('(未安装)')}")

package/kite_cli/commands/deps_install.py

@@ -28,12 +28,12 @@ def run_deps_install(args):
         # 1. 加载依赖锁定
         lock_data = load_dependencies_lock()
         if not lock_data:
-            print("✓ 无依赖锁定文件，跳过")
+            print("[OK] 无依赖锁定文件，跳过")
             return 0
 
         dependencies = lock_data.get("dependencies", {})
         if not dependencies:
-            print("✓ 无依赖要求，跳过")
+            print("[OK] 无依赖要求，跳过")
             return 0
 
         print(f"依赖锁定文件: {len(dependencies)} 个依赖")
@@ -41,11 +41,11 @@ def run_deps_install(args):
         # 2. 检查依赖
         deps_ok, deps_msg, deps_details = check_dependencies_installed()
         if deps_ok:
-            print(f"✓ 依赖库已安装且版本一致")
+            print(f"[OK] 依赖库已安装且版本一致")
             return 0
 
         # 3. 安装依赖
-        print(f"✗ {deps_msg}")
+        print(f"[X] {deps_msg}")
         if deps_details:
             if deps_details.get("missing"):
                 print(f"  缺失: {len(deps_details['missing'])} 个")
@@ -54,14 +54,14 @@ def run_deps_install(args):
 
         print(f"\n正在安装依赖...")
         if not install_dependencies():
-            print("✗ 依赖安装失败")
+            print("[X] 依赖安装失败")
             return 1
 
-        print(f"✓ 依赖安装成功")
+        print(f"[OK] 依赖安装成功")
         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/disable.py

@@ -0,0 +1,162 @@
+"""disable 命令实现 - 禁用模块"""
+import sys
+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.operation_log import log_operation
+from kite_cli.utils.i18n import t
+
+
+def run_disable(args):
+    """执行 disable 命令"""
+    module_name = args.name
+    location = args.location if hasattr(args, 'location') else None
+    skip_confirm = args.yes if hasattr(args, 'yes') else False
+
+    print(f"[Info] 禁用模块: {module_name}")
+
+    # 查找模块
+    if location:
+        locations = [location]
+    else:
+        locations = find_module_locations(module_name)
+        if not locations:
+            print(f"[Error] 未找到模块: {module_name}")
+            return 1
+
+    # 禁用所有找到的位置
+    success_count = 0
+    for loc in locations:
+        module_path = get_install_path(loc, module_name)
+        module_md = module_path / "module.md"
+
+        if not module_md.exists():
+            print(f"[Warning] 跳过 {loc}: 未找到 module.md")
+            continue
+
+        # 读取当前状态
+        current_state = read_module_state(module_md)
+
+        if current_state == "disabled":
+            print(f"[Info] {loc}: 模块已经是禁用状态")
+            continue
+
+        # 确认
+        if not skip_confirm:
+            if not confirm_action(f"确认禁用 {module_name} ({loc})？"):
+                print(f"[Cancelled] 跳过 {loc}")
+                continue
+
+        # 修改状态
+        if update_module_state(module_md, "disabled"):
+            print(f"[Success] ✓ {loc}: 已禁用")
+            success_count += 1
+
+            # 记录操作日志
+            log_operation("disable", {
+                "module": module_name,
+                "location": loc,
+                "old_state": current_state,
+                "new_state": "disabled"
+            })
+        else:
+            print(f"[Error] ✗ {loc}: 禁用失败")
+
+    if success_count > 0:
+        print()
+        print(f"[Success] 成功禁用 {success_count} 个位置的模块")
+        print("[Info] 重启 Kite 后生效")
+        return 0
+    else:
+        print()
+        print("[Error] 没有成功禁用任何模块")
+        return 1
+
+
+def find_module_locations(module_name):
+    """查找模块在哪些位置存在"""
+    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
+
+
+def read_module_state(module_md_path):
+    """读取模块的 state 字段"""
+    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('state:'):
+                        state = line.split(':', 1)[1].strip()
+                        state = state.strip('"').strip("'")
+                        return state
+
+        # 默认为 enabled
+        return "enabled"
+
+    except Exception:
+        return "enabled"
+
+
+def update_module_state(module_md_path, new_state):
+    """更新模块的 state 字段"""
+    try:
+        with open(module_md_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        # 解析 YAML frontmatter
+        if not content.startswith('---'):
+            # 没有 frontmatter，添加一个
+            new_content = f"---\nstate: {new_state}\n---\n\n{content}"
+        else:
+            parts = content.split('---', 2)
+            if len(parts) >= 3:
+                frontmatter = parts[1]
+                body = parts[2]
+
+                # 检查是否已有 state 字段
+                lines = frontmatter.split('\n')
+                state_found = False
+                new_lines = []
+
+                for line in lines:
+                    if line.strip().startswith('state:'):
+                        new_lines.append(f"state: {new_state}")
+                        state_found = True
+                    else:
+                        new_lines.append(line)
+
+                # 如果没有 state 字段，添加一个
+                if not state_found:
+                    # 在第一行后添加
+                    if len(new_lines) > 0 and new_lines[0] == '':
+                        new_lines.insert(1, f"state: {new_state}")
+                    else:
+                        new_lines.insert(0, f"state: {new_state}")
+
+                new_frontmatter = '\n'.join(new_lines)
+                new_content = f"---{new_frontmatter}---{body}"
+            else:
+                return False
+
+        # 写回文件
+        with open(module_md_path, 'w', encoding='utf-8') as f:
+            f.write(new_content)
+
+        return True
+
+    except Exception as e:
+        print(f"[Error] 更新失败: {e}")
+        return False

package/kite_cli/commands/enable.py

@@ -0,0 +1,162 @@
+"""enable 命令实现 - 启用模块"""
+import sys
+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.operation_log import log_operation
+from kite_cli.utils.i18n import t
+
+
+def run_enable(args):
+    """执行 enable 命令"""
+    module_name = args.name
+    location = args.location if hasattr(args, 'location') else None
+    skip_confirm = args.yes if hasattr(args, 'yes') else False
+
+    print(f"[Info] 启用模块: {module_name}")
+
+    # 查找模块
+    if location:
+        locations = [location]
+    else:
+        locations = find_module_locations(module_name)
+        if not locations:
+            print(f"[Error] 未找到模块: {module_name}")
+            return 1
+
+    # 启用所有找到的位置
+    success_count = 0
+    for loc in locations:
+        module_path = get_install_path(loc, module_name)
+        module_md = module_path / "module.md"
+
+        if not module_md.exists():
+            print(f"[Warning] 跳过 {loc}: 未找到 module.md")
+            continue
+
+        # 读取当前状态
+        current_state = read_module_state(module_md)
+
+        if current_state == "enabled":
+            print(f"[Info] {loc}: 模块已经是启用状态")
+            continue
+
+        # 确认
+        if not skip_confirm:
+            if not confirm_action(f"确认启用 {module_name} ({loc})？"):
+                print(f"[Cancelled] 跳过 {loc}")
+                continue
+
+        # 修改状态
+        if update_module_state(module_md, "enabled"):
+            print(f"[Success] ✓ {loc}: 已启用")
+            success_count += 1
+
+            # 记录操作日志
+            log_operation("enable", {
+                "module": module_name,
+                "location": loc,
+                "old_state": current_state,
+                "new_state": "enabled"
+            })
+        else:
+            print(f"[Error] ✗ {loc}: 启用失败")
+
+    if success_count > 0:
+        print()
+        print(f"[Success] 成功启用 {success_count} 个位置的模块")
+        print("[Info] 重启 Kite 后生效")
+        return 0
+    else:
+        print()
+        print("[Error] 没有成功启用任何模块")
+        return 1
+
+
+def find_module_locations(module_name):
+    """查找模块在哪些位置存在"""
+    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
+
+
+def read_module_state(module_md_path):
+    """读取模块的 state 字段"""
+    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('state:'):
+                        state = line.split(':', 1)[1].strip()
+                        state = state.strip('"').strip("'")
+                        return state
+
+        # 默认为 enabled
+        return "enabled"
+
+    except Exception:
+        return "enabled"
+
+
+def update_module_state(module_md_path, new_state):
+    """更新模块的 state 字段"""
+    try:
+        with open(module_md_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        # 解析 YAML frontmatter
+        if not content.startswith('---'):
+            # 没有 frontmatter，添加一个
+            new_content = f"---\nstate: {new_state}\n---\n\n{content}"
+        else:
+            parts = content.split('---', 2)
+            if len(parts) >= 3:
+                frontmatter = parts[1]
+                body = parts[2]
+
+                # 检查是否已有 state 字段
+                lines = frontmatter.split('\n')
+                state_found = False
+                new_lines = []
+
+                for line in lines:
+                    if line.strip().startswith('state:'):
+                        new_lines.append(f"state: {new_state}")
+                        state_found = True
+                    else:
+                        new_lines.append(line)
+
+                # 如果没有 state 字段，添加一个
+                if not state_found:
+                    # 在第一行后添加
+                    if len(new_lines) > 0 and new_lines[0] == '':
+                        new_lines.insert(1, f"state: {new_state}")
+                    else:
+                        new_lines.insert(0, f"state: {new_state}")
+
+                new_frontmatter = '\n'.join(new_lines)
+                new_content = f"---{new_frontmatter}---{body}"
+            else:
+                return False
+
+        # 写回文件
+        with open(module_md_path, 'w', encoding='utf-8') as f:
+            f.write(new_content)
+
+        return True
+
+    except Exception as e:
+        print(f"[Error] 更新失败: {e}")
+        return False

package/kite_cli/commands/export.py

@@ -0,0 +1,96 @@
+"""export 命令实现 - 导出已安装模块列表"""
+import json
+from pathlib import Path
+from kite_cli.utils.paths import get_install_path
+from kite_cli.core.install_info import read_install_info
+
+
+def run_export(args):
+    """执行 export 命令"""
+    location = args.location if hasattr(args, 'location') else None
+    format_type = args.format if hasattr(args, 'format') else 'text'
+
+    # 获取所有已安装模块
+    modules = []
+    locations = [location] if location 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
+
+                module_md = module_dir / 'module.md'
+                if not module_md.exists():
+                    continue
+
+                # 读取版本号
+                version = read_module_version(module_md)
+
+                # 读取安装信息
+                install_info = read_install_info(module_dir)
+
+                if install_info:
+                    source = install_info.get('source', {})
+                    modules.append({
+                        'name': module_dir.name,
+                        'version': version,
+                        'location': loc,
+                        'source_type': source.get('type'),
+                        'source_package': source.get('package', module_dir.name),
+                        'source_url': source.get('url', '')
+                    })
+        except Exception:
+            continue
+
+    if not modules:
+        print("[Info] 没有找到已安装的模块", file=__import__('sys').stderr)
+        return 0
+
+    # 输出
+    if format_type == 'json':
+        print(json.dumps(modules, indent=2, ensure_ascii=False))
+    else:  # text
+        for mod in modules:
+            if mod['source_type'] in ['pypi', 'npm']:
+                print(f"{mod['source_package']}@{mod['version']} --from {mod['source_type']} --location {mod['location']}")
+            elif mod['source_type'] == 'git':
+                print(f"{mod['source_url']} --from git --location {mod['location']}")
+
+    return 0
+
+
+def read_module_version(module_md_path):
+    """从 module.md 读取版本号"""
+    try:
+        with open(module_md_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        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()
+                        return version.strip('"').strip("'")
+        return "unknown"
+    except Exception:
+        return "unknown"